firmware.html

---
layout: base
---

<div class="heading">
  <div class="row">
    <div class="twelve columns">
      <h1>Firmware</h1>
    </div>
  </div>
</div>

<div class="row">
  <div class="eight columns">
    <p>Hier findest du eine Liste unterstützter Router-Modelle und ihre entsprechenden Firmwares.</p>

    <p><strong>Aktuelle Firmware-Version: {{ site.firmware_version }}</strong></p>
  </div>
</div>

<div class="row">
  <div class="eight columns">
    {% for groups in site.firmwares %}
    <h2>{{ groups[0] }}</h2>
    <table>
      <thead>
        <tr>
          <th>Modell</th>
          <th>Erstinstallation</th>
          <th>Upgrade</th>
        </tr>
      </thead>
      <tbody>
        {% for model in groups[1] %}
        <tr>
          <td>
            {{ model[0] }}
          </td>
          <td>
            {% for fw in model[1] %}
            {% if fw[1].factory %}
            {% if fw[0] %}
            <strong>{{ fw[0] }}:</strong>
            {% endif %}
            <a href="{{ fw[1].factory }}">factory</a>
            {% endif %}
            <br/>
            {% endfor %}
          </td>
          <td>
            {% for fw in model[1] %}
            {% if fw[1].sysupgrade %}
            {% if fw[0] %}
            <strong>{{ fw[0] }}:</strong>
            {% endif %}
            <a href="{{ fw[1].sysupgrade }}">sysupgrade</a>
            {% endif %}
            <br/>
            {% endfor %}
          </td>
        </tr>
        {% endfor %}
      </tbody>
    </table>
    {% endfor %}

    <p>
    Die Lübecker Freifunk-Firmware ist Freie Software. Sie basiert auf dem <a href="https://github.com/freifunk-gluon/gluon">Gluon-Framework</a> und <a href="https://openwrt.org/">OpenWrt</a> und darf nach den Bestimmungen der <a href="https://www.gnu.org/licenses/gpl-2.0.html">GNU General Public License</a> weiterverteilt und verändert werden.
    </p>
    <p>Das Gluon-Site-Repository befindet sich unter <a href="https://github.com/freifunk-gluon/site-ffhl">https://github.com/freifunk-gluon/site-ffhl</a>.</p>
  </div>
  <div class="four columns panel">
    <h5>Hardware Versionen</h5>
    <p>Bei einigen Modellen gibt es mehrere Hardware Versionen. Ist dies bei deinem Modell der Fall, musst du die entsprechende Firmware anhand des Typenschilds unter dem Knoten auswählen.</p>
    <p>Dieses Bild zeigt das Typenschild eines TP-Link TL-WR1043ND. Die Versionsangabe ist gelb markiert:</p>
    <a href="images/hardwareversion.png">
      <img src="images/hardwareversion.png" />
    </a>
  </div>
</div>

firmwares.rb

require 'net/http'
require 'uri'
require 'nokogiri'
require 'pp'

FIRMWARE_PREFIX = 'gluon-ffhl'
FIRMWARE_VERSION = '0.7'

FIRMWARE_REGEX = Regexp.new('^' + FIRMWARE_PREFIX + '-' + FIRMWARE_VERSION + '-')
FIRMWARE_BASE = 'http://luebeck.freifunk.net/firmware/' + FIRMWARE_VERSION + '/'

GROUPS = {
  "Allnet" => {
    models: [
      "ALL0315N"
    ],
    extract_rev: lambda { |model, suffix| nil },
  },
  "Buffalo" => {
    models: [
      "WZR-HP-AG300H/WZR-600DHP",
      "WZR-HP-G450H",
    ],
    extract_rev: lambda { |model, suffix| nil },
  },
  "D-Link" => {
    models: [
      "DIR-615",
      "DIR-825",
    ],
    extract_rev: lambda { |model, suffix| /^-rev-(.+?)(?:-sysupgrade)?\.bin$/.match(suffix)[1].upcase },
  },
  "GL-iNet" => {
    models: [
      "6408A",
      "6416A",
    ],
    extract_rev: lambda { |model, suffix| /^-(.+?)(?:-sysupgrade)?\.bin$/.match(suffix)[1] },
  },
  "Linksys" => {
    models: [
      "WRT160NL",
    ],
    extract_rev: lambda { |model, suffix| nil },
  },
  "NETGEAR" => {
    models: [
      "WNDR3700",
      "WNDR3800",
      "WNDR4300",
      "WNDRMAC"
    ],
    extract_rev: lambda { |model, suffix| /^(.*?)(?:-sysupgrade)?\.[^.]+$/.match(suffix)[1].sub(/^$/, 'v1') },
  },
  "TP-Link" => {
    models: [
      "CPE210",
      "CPE220",
      "CPE510",
      "CPE520",
      "TL-MR3020",
      "TL-MR3040",
      "TL-MR3220",
      "TL-MR3420",
      "TL-WA701N/ND",
      "TL-WA750RE",
      "TL-WA801N/ND",
      "TL-WA830RE",
      "TL-WA850RE",
      "TL-WA860RE",
      "TL-WA901N/ND",
      "TL-WDR3500",
      "TL-WDR3600",
      "TL-WDR4300",
      "TL-WDR4900",
      "TL-WR1043N/ND",
      "TL-WR2543N/ND",
      "TL-WR703N",
      "TL-WR710N",
      "TL-WR740N/ND",
      "TL-WR741N/ND",
      "TL-WR743N/ND",
      "TL-WR841N/ND",
      "TL-WR842N/ND",
      "TL-WR941N/ND",
    ],
    extract_rev: lambda { |model, suffix| /^-(.+?)(?:-sysupgrade)?\.bin$/.match(suffix)[1] },
  },
  "Ubiquiti" => {
    models: [
      "Bullet M",
      "Loco M",
      "Nanostation M",
      "UniFi AP Pro",
      "UniFi",
      "UniFiAP Outdoor",
    ],
    extract_rev: lambda { |model, suffix|
      rev = /^(.*?)(?:-sysupgrade)?\.bin$/.match(suffix)[1]

      if rev == '-xw'
        'XW'
      elsif model == 'Nanostation M' or model == 'Bullet M'
        'XM'
      else
        nil
      end
    },
    transform_label: lambda { |model|
      if model == 'Bullet M' then
        'Bullet M, Loco M'
      elsif model == 'UniFi' then
        'UniFi AP (LR)'
      else
        model
      end
    }
  },
  "x86" => {
    models: [
      "Generic",
      "KVM",
      "VirtualBox",
      "VMware",
    ],
    extract_rev: lambda { |model, suffix| nil },
  },
}

module Jekyll
  class Firmware
    attr_accessor :group
    attr_accessor :label
    attr_accessor :factory
    attr_accessor :sysupgrade
    attr_accessor :hwrev

    def to_liquid
      {
        "factory" => factory,
        "sysupgrade" => sysupgrade,
        "hwrev" => hwrev
      }
    end

    def to_s
      self.label
    end
  end

  class FirmwareListGenerator < Generator
    def generate(site)
      class << site
        attr_accessor :firmwares
        def site_payload
          result = super
          result["site"]["firmwares"] = self.firmwares
          result["site"]["firmware_version"] = FIRMWARE_VERSION
          result
        end
      end

      def get_files(url)
        uri = URI.parse(url)
        response = Net::HTTP.get_response uri
        doc = Nokogiri::HTML(response.body)
        doc.css('a').map do |link|
          link.attribute('href').to_s
        end.uniq.sort.select do |href|
          href.match(FIRMWARE_REGEX)
        end
      end

      def sanitize_model_name(name)
        name
          .downcase
          .gsub(/[^\w\-\.]+/, '-')
          .gsub(/\.+/, '.')
          .gsub(/[\-\.]*-[\-\.]*/, '-')
          .gsub(/-+$/, '')
      end

      def prefix_of(sub, str)
        str[0, sub.length].eql? sub
      end

      def find_prefix(name)
        @prefixes.each do |prefix|
          return prefix if prefix_of(prefix, name)
        end

        nil
      end

      firmwares = Hash[GROUPS.collect_concat { |group, info|
        info[:models].collect do |model|
          basename = FIRMWARE_PREFIX + '-' + FIRMWARE_VERSION + '-' + sanitize_model_name(group + ' ' + model)
          label = if info[:transform_label] then
                    info[:transform_label].call model
                  else
                    model
                  end
          [basename,
           {
             :extract_rev => info[:extract_rev],
             :model => model,
             :revisions => Hash.new { |hash, rev|
               fw = Firmware.new
               fw.label = label
               fw.group = group
               fw.hwrev = rev
               fw
             },
           }
          ]
        end
      }]

      @prefixes = firmwares.keys.sort_by { |p| p.length }.reverse

      factory = get_files(FIRMWARE_BASE + "factory/")
      sysupgrade = get_files(FIRMWARE_BASE + "sysupgrade/")

      factory.each do |href|
        basename = find_prefix href
        suffix = href[basename.length..-1]
        info = firmwares[basename]

        hwrev = info[:extract_rev].call info[:model], suffix

        fw = info[:revisions][hwrev]
        fw.factory = FIRMWARE_BASE + "factory/" + href
        info[:revisions][hwrev] = fw
      end

      sysupgrade.each do |href|
        basename = find_prefix href
        suffix = href[basename.length..-1]
        info = firmwares[basename]

        hwrev = info[:extract_rev].call info[:model], suffix

        fw = info[:revisions][hwrev]
        fw.sysupgrade = FIRMWARE_BASE + "sysupgrade/" + href
        info[:revisions][hwrev] = fw
      end

      firmwares.delete_if { |k, v| v[:revisions].empty? }

      groups = firmwares
               .collect { |k, v| v[:revisions] }
               .group_by { |revs| revs.values.first.label }
               .collect { |k, v| [k, v.first.sort] }
               .sort
               .group_by { |k, v| v.first[1].group }
               .to_a
               .sort

      site.firmwares = groups
    end
  end
end

Hier kann man noch einen style einführen um dem dann min-width:90% zu geben:

https://gist.github.com/rubo77/b953fe2ae13b8b588f37/revisions#diff-21daa95039bb003b7263253800c7a127R25

Ausserdem hab ich das dort noch mal noch allgemeiner gefasst, so dass alles spezifische oben zu konfigurieren ist.

sollte noch in https://github.com/ffnord/startseite eingepflegt werden

Und schon mal als vorrausplanung:
Dies lässt sich nicht bauen, wenn man als Pfad die experimental angibt:

firmwares.rb:229:in `block in generate': undefined method `length' for nil:NilClass (NoMethodError)
from /opt/ffki-startseite/_plugins/firmwares.rb:227:in `each'

aber wohl noch nicht so wichtig

update: rubo77/startseite@32f3f6d