Chube: Object-oriented bindings for the Linode API

Chube is a Python library providing an object-oriented interface to the Linode API, built on top of linode-python. It's very easy to use. But don't take my word for it; check out some examples!

Installation

Step 1: Install the PyPI package:

    pip install chube

Step 2 (optional): Give it your API key:

    echo -e "---\napi_key: <YOUR API KEY GOES HERE>" > ~/.chube

That's it!

To find your API key, log in to the Linode Manager, click on My Profile, and scroll down to the API Key section.

Usage

Chube can be used either interactively or as a library.

Interactive use: chuber

Chube is distributed with an executable script called chuber, which just drops you into a Python interpreter with an API connection ready to go. It requires that you've created the file ~/.chube as described in the Installation section.

chuber should be in your PATH; look at the Examples section to see how to use it.

Library

Chube can also be used as a library. It can either load your API key from ~/.chube like so:

    from chube import *
    load_chube_config()

Or you can feed it an API key from within the script, like so:

    from chube import *
    chube_api_handler.api_key = "RXIgbWFoIGdlcmQgQVBJIGtlcno"

Examples

If you're like me, you learn best by reading examples. Here are some.

They don't run the whole gamut of what Chube can do, but they should give you an idea of the conventions to expect.

List all Linodes whose names start with a given string

    for node in Linode.search(label_begins='foo-'):
        print node.label

To list each Linode with its public IP address(es),

    for node in Linode.search(label_begins='foo-'):
        pub_ips = [ip for ip in node.ipaddresses if ip.is_public]
        print node.label + "\t" + pub_ips

Create a Linode

    p = Plan.find(label="Linode 1024")
    d = Datacenter.find(location_begins="dallas")
    node = Linode.create(plan=p, datacenter=d, payment_term=1)

Set a node's label

    node = Linode.find(label='foo-host')
    node.label = "bar-host"
    node.save()

Determine whether a node is running

    for node in Linode.search():
        if not node.is_up():
            print "Node '%s' is NOT running" % (node.label,)

Add a disk to a Linode, based on a standard distribution

    node = Linode.find(label_begins='some-unique-linode')
    distro = Distribution.find(label="Debian 7")
    disk = node.create_disk(
        distribution=distro,
        label='foo-disk',
        size=8000,
        root_pass="god")

Boot a Linode

Continuing the last example,

    kern = Kernel.find(label_begins="latest 64 bit")
    config = Config.create(
        linode=node,
        kernel=kern,
        label="foo-config",
        disks=[disk, None, None, None, None, None, None, None, None])
    job = node.boot(config=config)

Reboot a Linode in single-user mode

    config = node.config[0]
    # For `init=/bin/bash` you'd use "binbash" instead of "single"
    config.run_level = "single"
    config.save()
    node.reboot()

Wait for a job to finish

Continuing the last example,

    job.wait()

Update a Stackscript

    stackscript = Stackscript.find(is_public=False, label="my-stack-script")
    stackscript.script = "#!/bin/bash\n\necho Hurr durr, I'm a stackscript"
    stackscript.rev_note = "Commit ID 123456789abcdef"
    stackscript.save()

Create a disk based on a Stackscript

    node = Linode.find(label="foo-host")
    distro = Distribution.find(label="Debian 7")
    stackscript = Stackscript.find(is_public=False, label="my-stack-script")
    # This is where you put your UDF responses:
    stack_input = StackscriptInput(param_1="blah blah", param_2="yadda yadda")
    stack_input.param_3 = "hippity hop"

    disk = Disk.create(linode=node,
                       stackscript=stackscript,
                       ss_input=stack_input,
                       distribution=distro,
                       label='foo-disk',
                       size=8000,
                       root_pass="god")

List the DNS records in a domain

    domain = Domain.find(domain="example.com")
    for record in domain.search_records():
        print "%-20s => %s" % (record.name, record.target)

Add DNS records to a domain

    domain = Domain.find(domain="example.com")
    domain.add_record(record_type="A", name="localhost", target="127.0.0.1")
    domain.add_record(record_type="MX", name="", target="mail.example.com",
                      priority=10)

Add an IP address to the AXFR transfer list

    domain = Domain.find(domain="example.com")
    domain.axfr_ips.append("127.0.0.1")

Change a DNS record's TTL

    record.ttl_sec = 600
    record.save()

Delete a DNS record

    domain = Domain.find(domain="example.com")
    record = domain.find_record(name="mail")
    record.destroy()

Create a Nodebalancer and name it

    dallas = Datacenter.find(label_begins='dallas')
    balancer = Nodebalancer.create(datacenter=dallas, payment_term=1)
    balancer.label = "my-kickass-nodebalancer"
    balancer.save()

Add a Config to a Nodebalancer

Continuing the example above...

    balancer_config = balancer.add_config()
    balancer_config.protocol = "http"
    balancer_config.port = 80
    balancer_config.save()

Add a Node to a Nodebalancer config

    http_config = balancer.find_config(protocol="http", port=80)
    node = http_config.add_node(label="webserver-06", address="192.168.255.255:80)

Change a node's attributes

    node_to_change = balancer_config.find_node(label="webserver-14")
    node_to_change.weight += 50
    node_to_change.save()