def publish(self, domain='yourdomainhere'):
        c.title = "Nodetraq -- DNS - Publish"
        c.selected_page = "dns"
        c.subpage = "publish"
        c.domain = domain

        prod = NodetraqCotendo()
        prod.GrabDNS(domain, 1)
        staging = NodetraqCotendo()
        staging.GrabDNS(domain, 1)

        results = ch.get_view('dns', 'configs')
        for r in results.rows:
            if r.value['environment'] == 'staging':
                staging.ImportDNS(r.value["config"], r.value["token"])
                break

        staging_config = staging.dns.config.splitlines(1)
        prod_config = prod.dns.config.splitlines(1)

        diff = ''.join(difflib.unified_diff(
                prod_config, staging_config, 'production', 'staging'))

        c.diff = diff
        return render('/dns/publish.mako')

    def index(self, domain='yourdomainhere'):
        c.title = "Nodetraq -- DNS"
        c.selected_page = "dns"
        c.subpage = "list"
        c.domain = domain

        cotendo = NodetraqCotendo()
        cotendo.GrabDNS(domain, 1)
        ch.select("nodetraq")

        # Sync views
        ch.sync_view('nodetraq/model/views')

        # Update CouchDB to have a copy of the latest dns entries.
        results = ch.get_view('dns', 'configs')
        doc = None
        for r in results.rows:
            if r.value['environment'] == 'staging':
                doc = couchdb.Document(r.value)
                cotendo.ImportDNS(r.value["config"], r.value['token'])
            if doc:
                if doc["config"] != cotendo.dns.config:
                    doc["config"] = cotendo.dns.config
                    doc["token"] = cotendo.dns.token
                    ch.save(doc)
        if not doc:
            doc = couchdb.Document({"doc_type": "dns",
                     "domain": domain,
                     "environment": "staging",
                     "token": cotendo.dns.token,
                     "config": cotendo.dns.config })
            ch.save(doc)

        c.records = cotendo.dns._entries
        return render('dns/list.mako')

    def index(self):
        c.title = 'Nodetraq -- Graphs'
        c.selected_page = 'graphs'
        c.subpage = 'index'

        c.graphs = Session.query(Graph).all()
        return render('/graphs/index.mako')

    def index(self):
        c.page = int(request.params['page'])\
                if 'page' in request.params else 1
        c.title = 'Nodetraq - Groups'
        c.selected_page = 'groups'
        c.subpage = 'list'
        c.heading = "Groups"
        c.filters = [
                { 'name': 'group', 'label': 'Group', 'type': 'text' }
            ]
        query, c.search_fields = get_fields_and_query(Session,
                Group, request.params)
        c.request_url = request.environ.get('PATH_INFO')
        if request.environ.get('QUERY_STRING'):
            c.request_url += '?' + request.environ['QUERY_STRING']
        c.group_count = query.count()

        c.link_append = '&' + urlencode(\
                [p for p in request.params.items()\
                    if p[0] != 'page'])
        if c.link_append == '&':
            c.link_append = None

        if 'show_all' in request.params:
            c.total_pages = 1
            c.current_page_count = 1
            c.groups = query.order_by('name').all()
        else:
            c.total_pages = (c.group_count+25-1)/25
            c.current_page_count = (c.page-1)*25
            c.groups = query.order_by('name')\
                    [c.current_page_count: c.current_page_count+25]

        c.all_groups, c.tag_sizes = self.get_tag_info()
        return render('/groups/list.mako')

    def index(self):
        c.title = 'Nodetraq - LoadBalancer'
        c.selected_page = 'loadbalancer'
        c.subpage = 'index'
        lb = LoadBalancer(ip='lb_iphere')
        pools = lb.get_pools()
        pools.sort()
        c.pool_count = len(pools)

        c.link_append = '&' + urlencode(
            [p for p in request.params.items()\
                 if p[0] != 'page'])
        if c.link_append == '&':
            c.link_append = None

        if 'show_all' in request.params:
            c.page = 1
            c.total_pages = 1
            c.current_page_count = 1
            c.members = self.get_members_status(Session, pools)
        else:
            c.page = int(request.params['page'])\
                    if 'page' in request.params else 1
            c.total_pages = (c.pool_count+25-1)/25
            c.current_page_count = (c.page-1)*25
            c.members = self.get_members_status(Session,
                    pools[c.current_page_count:c.current_page_count+25])

        return render('/loadbalancer/index.mako')

 def edit_studio(self, id):
     c.studio = Session.query(Studio).filter(Studio.id == id).first()
     c.title = "Nodetraq -- Edit Studio"
     c.header = c.studio.name
     c.selected_page = "nodes"
     c.subpage = "edit_studio"
     return render('/nodes/studios/edit.mako')

    def show_dbbackups(self):
        c.title = "Nodetraq -- Show Database Backups"
        c.selected_page = "nodes"
        c.subpage = "database"
        sort = None

        c.dbbackups = Session.query(NodeDatabaseBackup).all()
        if not 'sort' in request.params:
            sort = 'server'
        else:
            sort = request.params['sort']

        if sort == 'server':
            c.dbbackups = sorted(
                c.dbbackups, key=lambda backup: backup.server.hostname)
        elif sort == 'storage':
            c.dbbackups = sorted(
                c.dbbackups, key=lambda backup: backup.storage.hostname)
        elif sort == 'directory':
            c.dbbackups = sorted(
                c.dbbackups, key=lambda backup: backup.directory)
        elif sort == 'enabled':
            c.dbbackups = sorted(
                c.dbbackups, key=lambda backup: backup.enabled)

        c.sort = sort

        return render('/nodes/show_dbbackups.mako')

    def show_game(self, id):
        c.game = Session.query(Game).filter(Game.id == id).first()
        c.title = "Nodetraq -- Game: %s" % c.game.name
        c.header = c.game.name
        c.selected_page = "nodes"
        c.subpage = "show_game"

        c.groups = [
            {'name': 'PE-1950', 'nodes': []},
            {'name': 'PE-2950', 'nodes': []},
            {'name': 'PE-R410', 'nodes': []},
            {'name': 'PE-R610', 'nodes': []},
            {'name': 'PE-R710', 'nodes': []},
            {'name': 'vm', 'nodes': []},
            {'name': 'unknown', 'nodes': []}
            ]

        group_list = lambda groups: [g.name for g in groups]
        for node in c.game.nodes:
            grouped = False
            for group in c.groups:
                if group['name'] in group_list(node.groups):
                    group['nodes'].append(node)
                    grouped = True

            if not grouped:
                c.groups[len(c.groups)-1]['nodes'].append(node)

        return render('/nodes/games/show.mako')

    def rrd_file(self, id):
        response.content_type = 'text/plain'

        if id.isdigit():
            graph_data = Session.query(Graph)\
                .filter(Graph.id == int(id)).first()
        else:
            graph_data = Session.query(Graph)\
                .filter(Graph.name == id).first()

        c.graph = graph_data.filename[1:]
        hostnames = [n.hostname for n in graph_data.get_hosts()]

        c.datasource = generate_rrd_sequence_map(
            hostnames, graph_data.get_rrds())

        c.title = graph_data.name

        if len(c.datasource) == 2:
            c.colors = ['Lime', 'Red']
            c.brmod = 2
        else:
            c.colors = ['Lime', 'Teal', 'Maroon']
            c.brmod = 3

        return render('/graphs/graph.mako')

    def add_record(self, domain='yourdomainhere'):
        c.title = "Nodetraq -- DNS - Add Record"
        c.selected_page = "dns"
        c.subpage = "add_record"
        c.domain = domain

        return render('dns/add_record.mako')

    def add(self):
        c.group = Session.query(Group).filter(Group.id == id).first()
        c.title = 'Nodetraq - Group - Add'
        c.selected_page = 'groups'
        c.subpage = 'add'

        return render('/groups/add.mako')

 def show(self, pool):
     c.title = 'Nodetraq - Loadbalancer - Show'
     c.selected_page = 'loadbalancer'
     c.subpage = 'show'
     lb = LoadBalancer(ip='your_lb_ip')
     c.members = self.get_members_status(Session, [pool])[0]
     return render('/loadbalancer/show.mako')

    def index(self):
        c.title = 'Nodetraq - Network'
        c.selected_page = 'network'
        c.subpage = 'index'

        c.network_devices = Session.query(NetworkDevice).all()
        return render('/network/index.mako')

    def edit_record(self, domain='yourdomainhere', type=None, host=''):
        c.title = "Nodetraq -- DNS - Edit Record"
        c.selected_page = "dns"
        c.subpage = "edit_record"
        c.domain = domain

        cotendo = NodetraqCotendo()
        cotendo.GrabDNS(domain, 1)
        # check if record exists, if it does, update it otherwise
        results = ch.get_view('dns', 'configs')
        doc = None
        for r in results.rows:
            if r.value['environment'] == 'staging':
                cotendo.ImportDNS(r.value["config"], r.value['token'])
                doc = couchdb.Document(r.value)
                break

        c.record = cotendo.dns.get_record(type, host)
        if not c.record:
            session['flash'] = "Not a valid record"
            session.save()
            return redirect(url(controller="dns",
                                action="index", domain=domain))

        return render('/dns/edit_record.mako')

 def namelist(self, format='mako'):
     c.nodes = Session.query(Node.hostname).all()
     if format == 'json':
         response.content_type = 'application/json'
     elif format == 'xml':
         response.content_type = 'application/xml'
     return render('/nodes/namelist/list.' + format)

    def index(self):
        c.title = 'Nodetraq - Dashboard'
        c.selected_page = 'dashboard'
        c.subpage = 'index'

        c.sync_issues = self.get_sync_issues()['issues']
        return render('/dashboard/index.mako')

    def info(self, id):
        c.title = "Nodetraq - Activity - Info"
        c.selected_page = "activity"
        c.subpage = "info"

        c.activity = Session.query(Activity).filter(Activity.id == id).first()
        c.Session = Session
        return render("/activity/info.mako")

 def show(self, id, vhostid=None):
     c.title = 'Nodetraq - Vhost - Edit'
     c.selected_page = 'nodes'
     c.subpage = 'vhost'
     c.header = 'Show Vhost'
     c.vhostid = vhostid
     c.node_id = id
     return render('/nodes/vhosts/show.mako')

    def new(self, id):
        c.title = 'Nodetraq - vhosts'
        c.selected_page = 'nodes'
        c.subpage = 'vhosts'
        c.header = 'Nodes:vhosts'
        c.node_id = id

        return render('/nodes/vhosts/new.mako')

    def show(self, id):
        c.title = 'Nodetraq - Network Devices'
        c.selected_page = 'network'
        c.subpage = 'show'

        c.network_device = Session.query(NetworkDevice).filter(
            id == NetworkDevice.id).first()
        return render('/network/show.mako')