Initial import of "Uriel".

diff --git a/www/include/style.css b/www/include/style.css
index 7334d65ca32590f589247817f6c34fcb69bc63a9..fcdc13e7c87697f4a9af6902699698ebbebba07b 100644 (file)
--- a/www/include/style.css
+++ b/www/include/style.css
@@ -661,3 +661,30 @@ left: 60px; /*position where enlarged image should offset horizontally */
        position: relative;
        width: 100%;
        }
+
+.ui-tabs .ui-tabs-hide {
+     display: none;
+}
+
+table.uriel {
+       width: 100%;
+       border: 1px solid #880400;
+}
+
+table.uriel td {
+       padding: 4px;
+}
+
+table.uriel td.item {
+       font-weight: bold;
+}
+
+table.uriel td.value {
+       text-align: right;
+}
+
+table.uriel td.footer {
+       text-align: right;
+       background-color: #ddd;
+       border-top: 1px solid #666;
+}

diff --git a/www/pages/uriel.py b/www/pages/uriel.py
new file mode 100644 (file)
index 0000000..42a0db7
--- /dev/null
+++ b/www/pages/uriel.py
@@ -0,0 +1,150 @@
+#!/bin/bash
+
+import web
+import web.elements
+from web.javascript import Javascript
+from web.urieldb import Urieldb
+
+from web.info import Info
+info = Info()
+
+class Content(web.Content):
+       def __init__(self):
+               web.Content.__init__(self)
+               
+               # ID, function, lang tuple
+               self.tabs = [ ("tab-os",     self.tab_os,     { "en" : "OS", "de" : "System",},),
+                                         ("tab-arch",   self.tab_arch,   { "en" : "Architecture", "de": "Architektur",},),
+                                         ("tab-lang",   self.tab_lang,   { "en" : "Languages", "de" : "Spracheinstellung",},),
+                                         ("tab-cpu",    self.tab_cpu,    { "en" : "CPU", "de" : "Prozessor",},),
+                                         ("tab-ram",    self.tab_ram,    { "en" : "RAM", "de" : "Hauptspeicher",},),
+                                         ("tab-vendor", self.tab_vendor, { "en" : "Vendor", "de" : "Hersteller",},),
+                                         ("tab-model",  self.tab_model,  { "en" : "Model", "de" : "Modell",},),
+                                         ("tab-formfactor", self.tab_formfactor, { "en" : "Formfactor", "de" : "Formfaktor",},),
+                                         ("tab-storage", self.tab_storage, { "en" : "Storage", "de" : "Datenspeicher",},),]
+
+               self.db = Urieldb()
+
+       def __call__(self, lang):
+               ret = """<h3>IPFire Uriel</h3>
+                                       <table class="uriel">
+                                               <tr>
+                                                       <td>Total hosts:</td>
+                                                       <td>""" + "%s" % self.db.count() + """</td>
+                                               </tr>
+                                       </table>"""
+
+               ret +=  """<div id="tabs">
+                                       <ul>"""
+
+               # Create the links
+               for tab, function, langs in self.tabs:
+                       ret += """<li><a href="#%s">%s</a></li>""" % (tab, langs[lang],)
+               ret += "</ul>"
+
+               # Do the div containers
+               for tab, function, langs in self.tabs:
+                       ret += """<div id="%s">%s</div>""" % (tab, function(lang),)
+
+               ret += "</div>"
+
+               return ret
+
+       def table(self, item, lang):
+               ret = """<table class="uriel">"""
+
+               results, total = self.db.table(item, sort=1, consolidate=1)
+
+               if not total:
+                       ret += """<tr><td class="item" colspan="2">There is no data available.</td></tr>"""
+
+               else:
+                       for result, value in results:
+                               ret += """<tr><td class="item">%s</td><td class="value">%d%%</td></tr>""" % \
+                                       (result, int(value * 100 / total))
+
+                       ret += """<tr>
+                                               <td class="footer" colspan="2">%s/%s (%d%%) of the known hosts provide this information</td>
+                                         </tr>""" % (total, self.db.count(), total * 100 / int(self.db.count()))
+
+               return ret + "</table>"
+       
+       def table_range(self, item, lang, unit, ranges):
+               ret = """<table class="uriel">"""
+
+               ranges2 = {}
+               i = 0
+               for min, max in ranges:
+                       ranges2[i] = { "min"   : min,
+                                                  "max"   : max,
+                                                  "count" : 0, }
+                       i += 1
+               ranges = ranges2
+               
+               results, total = self.db.table(item)
+
+               if not total:
+                       ret += """<tr><td class="item" colspan="2">There is no data available.</td></tr>"""
+
+               else:
+                       for i in results:
+                               for range in ranges.keys():
+                                       if i >= ranges[range]["min"] and i <= ranges[range]["max"]:
+                                               ranges[range]["count"] += 1
+                                               break
+
+                       for range in ranges.keys():
+                               ret += """<tr><td class="item">%s</td><td class="value">%d%%</td></tr>""" % \
+                                       ("in between %s and %s %s" % (ranges[range]["min"], ranges[range]["max"], unit),
+                                       ranges[range]["count"] * 100 / total)
+       
+                       ret += """<tr>
+                                               <td class="footer" colspan="2">%s/%s (%d%%) of the known hosts provide this information</td>
+                                         </tr>""" % (total, self.db.count(), total * 100 / int(self.db.count()))
+
+               return ret + "</table>"
+
+       def tab_os(self, lang):
+               return self.table("system", lang)
+
+       def tab_arch(self, lang):
+               return self.table("arch", lang)
+
+       def tab_lang(self, lang):
+               return self.table("lang", lang)
+
+       def tab_cpu(self, lang):
+               return self.table("cpu_model", lang) + \
+                       self.table_range("cpu_mhz", lang, unit="MHz", ranges=((1, 132), (133, 265),
+                               (266, 511), (512, 1023), (1024, 1535), (1536, 2047), (2048, 2559),
+                               (2560, 3071), (3072, 4096)))
+
+       def tab_ram(self, lang):
+               return self.table_range("ram_mb", lang, unit="MBytes", 
+                       ranges=((1,63), (64, 127), (128, 255), (256, 511), (512, 1023),
+                                       (1024, 4095), (4096, 16383)),)
+       
+       def tab_vendor(self, lang):
+               return self.table("vendor", lang)
+
+       def tab_model(self, lang):
+               return self.table("model", lang)
+       
+       def tab_formfactor(self, lang):
+               return self.table("formfactor", lang)
+       
+       def tab_storage(self, lang):
+               return self.table("storage", lang)
+
+
+page = web.Page()
+page.content = Content()
+page.sidebar = web.elements.DevelopmentSidebar()
+page.javascript = Javascript(1, 1)
+page.javascript.write("""
+       <script type="text/javascript">
+               $(function() {
+                       $("#tabs").tabs();
+               });
+       </script>
+""")

diff --git a/www/rpc.py b/www/rpc.py
index 059f56cbd1382aeccc749ef17d02b8e1f2ca1197..407b228dec2548f5168a2d423a9edfde8383f650 100644 (file)
--- a/www/rpc.py
+++ b/www/rpc.py
@@ -8,9 +8,14 @@ from rpc_functions import *
 form = cgi.FieldStorage()
 method = form.getfirst("method")
 id     = form.getfirst("id")
-params = form.getlist("params")
 
-methods = { "cluster_get_info" : cluster_get_info }
+params = None
+param_string = form.getfirst("params")
+if param_string:
+       params = json.loads(param_string)
+
+methods = { "cluster_get_info" : cluster_get_info,
+                       "uriel_send_info"  : uriel_send_info, }
 
 if method and methods.has_key(method):
        print json.dumps({ "version": "1.1",

diff --git a/www/rpc_functions.py b/www/rpc_functions.py
index ca5614f07d0baa453990d913207298cb3a78b721..02f87f72668d2695f93b153ab5dec7a8ca0eff0a 100644 (file)
--- a/www/rpc_functions.py
+++ b/www/rpc_functions.py
@@ -1,5 +1,7 @@
 #!/usr/bin/python
 
+import time
+
 import web.info
 
 info = web.info.Info()
@@ -8,3 +10,26 @@ def cluster_get_info(params):
        import web.cluster
        cluster = web.cluster.Cluster(info["hosting"]["cluster"])
        return cluster.json
+
+def uriel_send_info(params):
+       import web.urieldb
+       db = web.urieldb.Urieldb()
+       
+       id = None
+       items = {}
+       for (item, value) in params.items():
+               if item == "id":
+                       id = value
+               if item not in web.urieldb.allowed_items:
+                       continue
+               items[item] = value
+
+       # We need an id
+       if not id:
+               return
+
+       for item, value in items.items():
+               db.set(id, item, value)
+
+       # Save date of last modification
+       db.set(id, "date", "%s" % int(time.time()))

diff --git a/www/uriel_test.py b/www/uriel_test.py
new file mode 100644 (file)
index 0000000..c95f855
--- /dev/null
+++ b/www/uriel_test.py
@@ -0,0 +1,36 @@
+#!/usr/bin/python
+
+import sys
+import urlgrabber
+import urllib
+import simplejson as json
+
+data = {}
+id = None
+
+for arg in sys.argv[1:]:
+       if not id:
+               id = data["id"] = arg
+               continue
+
+       try:
+               item, value = arg.split("=")
+       except:
+               print "Cannot split arg: ", arg
+               continue
+       
+       value = value.strip("\"")
+
+       data[item] = value
+
+if not data:
+       print "No data to send."
+       sys.exit(0)
+
+request = { "id"     : "null",
+                       "method" : "uriel_send_info",
+                       "params" : json.dumps(data), }
+
+g = urllib.urlopen("http://www.ipfire.org/rpc.py", data=urllib.urlencode(request))
+print g.read()
+g.close()

diff --git a/www/web/urieldb.py b/www/web/urieldb.py
new file mode 100644 (file)
index 0000000..d44d5b5
--- /dev/null
+++ b/www/web/urieldb.py
@@ -0,0 +1,87 @@
+#!/usr/bin/python
+
+import operator
+import MySQLdb as sql
+
+allowed_items = [ "cpu_mhz", "cpu_model", "formfactor", "lang", "model",
+                                 "ram_mb", "storage_mb", "system", "vendor", ]
+
+class Urieldb(object):
+       _name = "uriel"
+       _table = "hosts"
+
+       def __init__(self):
+               self.connection = sql.connect(user="uriel", db=self._name)
+
+               self._count = None
+
+       def cursor(self):
+               return self.connection.cursor()
+
+       def table(self, item, sort=0, consolidate=0):
+               c = self.cursor()
+               c.execute("SELECT value FROM %s WHERE item = '%s'" % (self._table, item,))
+
+               count = 0
+               results = {}
+               ret = []
+
+               if consolidate:
+                       result = c.fetchone()
+                       while result:
+                               count += 1
+                               result = "%s" % result
+       
+                               if results.has_key(result):
+                                       results[result] += 1
+                               else:
+                                       results[result] = 1
+                               
+                               result = c.fetchone()
+       
+                       for i in results.items():
+                               ret.append(i)
+       
+                       if sort:
+                               ret = sorted(ret, key=operator.itemgetter(1))
+                               ret.reverse()
+               
+               else:
+                       result = c.fetchone()
+                       while result:
+                               ret.append(int("%s" % result))
+                               result = c.fetchone()
+
+                       if sort:
+                               ret.sort()
+
+                       count = len(ret)
+
+               c.close()
+               return (ret, count)
+
+       def count(self):
+               if not self._count:
+                       c = self.cursor()
+                       c.execute("SELECT COUNT(DISTINCT(id)) FROM %s" % self._table)
+                       self._count = int("%s" % c.fetchone())
+                       c.close()
+               return self._count
+
+       def get(self, id, item):
+               c = self.cursor()
+               c.execute("SELECT value FROM %s WHERE id = '%s' AND item = '%s'" % \
+                       (self._table, id, item,))
+               ret = c.fetchall() or None
+               c.close()
+               return ret
+
+       def set(self, id, item, value):
+               c = self.cursor()
+               if self.get(id, item):
+                       c.execute("UPDATE %s SET value = '%s' WHERE id = '%s' AND item = '%s'" % \
+                               (self._table, value, id, item,))
+               else:
+                       c.execute("INSERT INTO %s(id, item, value) VALUES('%s', '%s', '%s')" % \
+                               (self._table, id, item, value))
+               c.close()