bandshell 0.0.8

data/bin/bandshell-control.rb

@@ -0,0 +1,11 @@
+#Daemon control for the Bandshell daemon
+#Usage: ruby myserver_control.rb start|stop|restart
+
+require 'rubygems'
+require 'daemons'
+
+Daemons.run_proc('bandshell-daemon.rb') do
+  loop do
+    sleep(5)
+  end
+end

data/bin/bandshell-daemon.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+#Requires "daemons" gem
+
+#Starts the Web App Server & verifies that it is still alive
+#Starts the Browser & verifies that it is still alive
+#Periodically uses local library methods to check for updates from the server
+#Controls screen according to rules downloaded from server
+
+#Start the daemon loop - everything happens in there
+loop do
+  sleep(5)
+end

data/bin/concerto_configserver

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+begin
+	require 'app.rb'
+rescue LoadError => e
+	require 'rubygems'
+	path = File.expand_path '../../web', __FILE__
+	$:.unshift(path) if File.directory?(path) && !$:.include?(:path)
+	require 'app.rb'
+end

data/bin/concerto_netsetup

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'concerto_client/netconfig'
+
+ConcertoConfig::configure_system_network
+

data/lib/config_store.rb

@@ -0,0 +1,48 @@
+require 'live_image'
+require 'fileutils'
+
+# A key/value store for strings.
+# Right now implemented as disk files.
+module ConcertoConfig
+	module ConfigStore
+		@@path = nil
+
+		def self.read_config(name, default='')
+			initialize_path if not @@path			
+			file = File.join(@@path, name)
+			rofile = File.join(@@ropath, name)
+
+			# Check the read/write config location first. If nothing there,
+			# check the read-only location. If nothing is there, return default.
+			# This way writes can be made at runtime on read-only media while
+			# still allowing some settings to be "baked into" the media.
+			if File.exist?(file)
+				IO.read(file)
+			elsif File.exist?(rofile)
+				IO.read(rofile)
+			else
+				default
+			end
+		end
+
+		# Write a config to the read/write configuration location.
+		def self.write_config(name, value)
+			initialize_path if not @@path
+			file = File.join(@@path, name)
+
+			File.open(file, 'w') do |f|
+				f.write value
+			end
+		end
+
+		def self.initialize_path
+			@@ropath = File.join(LiveImage.mountpoint, 'concerto', 'config')
+			if LiveImage.readonly?
+				@@path = '/tmp/concerto/config'
+			else
+				@@path = @@ropath
+			end
+			FileUtils.mkdir_p @@path
+		end
+	end
+end

data/lib/live_image.rb

@@ -0,0 +1,27 @@
+require 'tempfile'
+
+# Functions for dealing with the live image
+# (where it's mounted, if it's read-only, etc)
+module ConcertoConfig
+	module LiveImage
+		def self.mountpoint
+			'/live/image'
+		end
+
+		def self.readonly?
+			# on a readonly file system this will fail
+			if not File.exist? self.mountpoint
+				true
+			else
+				begin
+					f = Tempfile.new('test', self.mountpoint)
+					f.close!
+					false
+				rescue 
+					# if the tempfile creation bombs we assume readonly
+					true
+				end
+			end
+		end
+	end
+end

data/lib/netconfig.rb

@@ -0,0 +1,542 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'json'
+require 'ipaddress'
+require 'config_store'
+
+# The big idea here is that we have connection methods (layer 2)
+# and addressing methods (layer 3) and by combining that configuration
+# information we end up with a complete network configuration.
+#
+# Each general layer-2 and layer-3 connection method is represented
+# as a class; adding the specific details creates an instance of the class.
+# The configuration is serialized as the name of the class plus the details
+# needed to reconstruct the instance.
+#
+# Each instance can contribute lines to /etc/network/interfaces,
+# the Debian standard network configuration file.
+# Each instance also has the opportunity to write out other configuration
+# files such as wpa_supplicant.conf, resolv.conf etc.
+
+class Module
+	# Get the name of a class/module and strip off any leading modules.
+	# This is useful in determining arguments for Module#const_get.
+    def basename
+        name.gsub(/^.*::/, '')
+    end
+end
+
+module ConcertoConfig
+    # The Debian interfaces configuration file we are going to write out.
+    INTERFACES_FILE='/etc/network/interfaces'
+
+    # Some useful interface operations.
+    class Interface
+        # Wrap an interface name (eth0, wlan0 etc) with some useful operations.
+        def initialize(name)
+            @name = name
+        end
+
+        # Get the name of the interface as a string.
+        attr_reader :name
+
+        # Get the (first) IPv4 address assigned to the interface.
+        # Return "0.0.0.0" if we don't have any v4 addresses.
+        def ip
+            if ifconfig =~ /inet addr:([0-9.]+)/
+                $1
+            else
+                "0.0.0.0"
+            end
+        end
+
+        # Get the physical (mac, ethernet) address of the interface.
+        def mac
+            File.open("/sys/class/net/#{@name}/address") do |f|
+                f.read.chomp
+            end
+        end
+
+        def up
+            system("/sbin/ifconfig #{@name} up")
+        end
+
+        def down
+            system("/sbin/ifconfig #{@name} down")
+        end
+
+        def ifup
+            system("/sbin/ifup #{@name}")
+        end
+
+        def ifdown
+            system("/sbin/ifdown #{@name}")
+        end
+
+        def up?
+            if ifconfig =~ /UP/
+                true
+            else
+                false
+            end
+        end
+
+        def medium_present?
+            brought_up = false
+            result = false
+
+            if not up?
+                brought_up = true
+                up
+                sleep 10
+            end
+
+            if ifconfig =~ /RUNNING/
+                result = true
+            end
+            
+            if brought_up
+                down
+            end
+
+            result
+        end
+    private
+        def ifconfig
+            `/sbin/ifconfig #{@name}`
+        end
+    end
+
+    # (Instance) methods that must be defined by all connection and 
+    # addressing method classes
+    # 
+    # creation and serialization:
+    #
+    # initialize(args={}): Create a new instance. When unserializing the args 
+    # hash created during serialization is passed in.
+    #
+    # args: return a hash of data needed to reconstruct the instance. This 
+    # hash will be passed to initialize() when unserializing.
+    #
+    # OS-level configuration:
+    #
+    # write_configs: Write out any additional configuration files needed 
+    # (e.g. resolv.conf, wpa_supplicant.conf, ...)
+    #
+    # config_interface_name (only for connection methods): return the name of 
+    # the physical interface to be used for the connection
+    #
+    # addressing_type (only for addressing methods): return the name of the 
+    # addressing method (dhcp, static, manual...) to be used in the Debian
+    # network configuration file /etc/network/interfaces.
+    #
+    # interfaces_lines: an array of strings representing lines to be added
+    # to the /etc/network/interfaces file after the line naming the interface.
+    #
+    # Stuff for the Web interface:
+    #
+    # safe_assign: return an array of symbols representing fields the user 
+    # should be allowed to modify.
+    #
+    # validate: check that the internal configuration is at least somewhat 
+    # consistent and stands a chance of working; throw exception if not
+    # (FIXME! need a better error handling mechanism)
+    # 
+    # and attr_accessors for everything the web interface 
+    # should be able to assign to.
+    #
+    # Everyone must define a class method self.description as well.
+    # This returns a string that is displayed in the web interface dropdowns
+    # because using plain class identifiers there doesn't look good.
+    # This should be something short like "Wired Connection".
+
+    # Layer 2 connection via wired media.
+    # We will look for wired interfaces that have media connected,
+    # or use an interface chosen by the user via the args. There's
+    # nothing extra to be contributed to the interfaces file besides
+    # the name of the interface to be used.
+    class WiredConnection
+        def initialize(args={})
+            if args['interface_name']
+                @interface_name = args['interface_name']
+            end
+        end
+
+        def write_configs
+            # We don't need any.
+        end
+
+        def config_interface_name
+            if @interface_name && @interface_name.length > 0
+                # the user has specified an interface to use
+                @interface_name
+            else
+                # scan for the first wired interface that has media
+                scan_interfaces
+            end
+        end
+
+        # If interface_name is something other than nil or the empty string,
+        # we will override the automatic detection and use that interface.
+        attr_accessor :interface_name
+
+        def safe_assign
+            [ :interface_name ]
+        end
+
+        def args
+            {
+                'interface_name' => @interface_name
+            }
+        end
+        
+        def interfaces_lines
+            []
+        end
+
+        def validate
+            if @interface_name != ''
+                if self.class.interfaces.find { 
+                        |iface| iface.name == @interface_name 
+                }.nil?
+                    fail "The interface doesn't exist on the system"
+                end
+            end  
+        end
+
+        # Try to find all wired interfaces on the system.
+        def self.interfaces
+            # This is somewhat Linux specific and may miss some oddballs.
+            devices = Dir.glob('/sys/class/net/eth*')
+            devices.map { |d| Interface.new(File.basename(d)) }
+        end
+
+        def self.description
+            "Wired connection"
+        end
+
+    private
+        # Find the first wired interface with medium present. If none
+        # is found default to eth0.
+        def scan_interfaces
+            first_with_medium = self.class.interfaces.find { 
+                |iface| iface.medium_present? 
+            }
+
+            if first_with_medium
+                first_with_medium.name
+            else
+                # if we get here no interface was found with a cable attached
+                # default to eth0 and hope for the best
+                STDERR.puts "warning: no suitable interface found, using eth0"
+                'eth0'
+            end
+        end
+    end
+
+    # 802.11* unencrypted wireless connections.
+    # These are managed by wpa_supplicant on Debian so we need to create its
+    # configuration file and link it to the interfaces file.
+    class WirelessConnection
+        def initialize(args={})
+            @ssid = args['ssid'] || ''
+            @interface_name = args['interface_name'] if args['interface_name']
+            @wpa_config_file = '/tmp/wpa_supplicant.concerto.conf'
+        end
+
+        attr_accessor :ssid, :interface_name
+
+        def config_interface_name
+            # If the user has requested a specific interface, use it.
+            # Otherwise, just pick the first wlan interface, assuming
+            # it works and all wlan interfaces have approximately equal
+            # reception. When this assumption is wrong the user must force.
+            if @interface_name && @interface_name != ''
+                @interface_name
+            else
+                self.class.interfaces[0].name
+            end
+        end
+
+        def validate
+            if @ssid == ''
+                fail "Need SSID for wireless connection"
+            end
+        end
+
+        def safe_assign
+            [ :ssid, :interface_name ]
+        end
+
+        def write_configs
+            # Write a wpa_supplicant.conf file for an unsecured network.
+            File.open(@wpa_config_file, 'w') do |wpaconf|
+                # long lines, sorry!
+                wpaconf.puts "ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev"
+                wpaconf.puts "network={"
+                wpaconf.puts "ssid=\"#{@ssid}\""
+                wpaconf.puts "scan_ssid=1"
+                wpaconf.puts "key_mgmt=NONE"
+                wpaconf.puts "}"
+            end
+        end
+
+        def interfaces_lines
+            # This links the wpa config to the interfaces file.
+            ["wpa-conf #{@wpa_config_file}"]
+        end
+
+        def args
+            {
+                'interface_name' => @interface_name,
+                'ssid' => @ssid
+            }
+        end
+
+        def self.description
+            "Wireless connection (no encryption)"
+        end
+
+        def self.interfaces
+            # Again this is not guaranteed to be a catch all.
+            devices = Dir.glob('/sys/class/net/{ath,wlan}*')
+            devices.map { |d| Interface.new(File.basename(d)) }
+        end
+    end
+
+    # Static IPv4 addressing.
+    # We use the IPAddress gem to validate that the address information
+    # is vaguely correct (weeding out errors like the gateway 
+    # being on another subnet)
+    class StaticAddressing
+        def initialize(args={})
+            @nameservers = args['nameservers']
+            @address = args['address']
+            @netmask = args['netmask']
+            @gateway = args['gateway']
+        end
+
+        def addressing_type
+            'static'
+        end
+
+        def args
+            {
+                'address' => @address,
+                'netmask' => @netmask,
+                'gateway' => @gateway,
+                'nameservers' => @nameservers
+            }
+        end
+
+        def interfaces_lines
+            [
+                "address #{@address}",
+                "netmask #{@netmask}",
+                "gateway #{@gateway}"
+            ]
+        end
+
+
+        def write_configs
+            File.open('/etc/resolv.conf','w') do |resolvconf|
+                @nameservers.each do |nameserver|
+                    resolvconf.puts("nameserver #{nameserver}");
+                end
+            end
+        end
+
+        def self.description
+            "Static Addressing"
+        end
+
+        attr_accessor :address, :netmask, :gateway, :nameservers
+
+        def safe_assign
+            [ :address, :netmask, :gateway, :nameservers_flat ]
+        end
+
+        def validate
+            @address.strip!
+            @netmask.strip!
+            @gateway.strip!
+
+            if not IPAddress.valid_ipv4?(@address)
+                fail "Static address is invalid"
+            end
+
+            p @netmask
+            if not IPAddress.valid_ipv4_netmask?(@netmask)
+                fail "Static netmask is invalid"
+            end
+
+            p @netmask
+            subnet = IPAddress::IPv4.new(@address)
+            subnet.netmask = @netmask
+            if not subnet.include? IPAddress::IPv4.new(gateway)
+                fail "Gateway provided is unreachable"
+            end
+        end
+
+        # These next two methods are for the web interface, where it's
+        # more convenient to enter a bunch of nameservers on one line
+        # than to have to deal with an array of fields.
+        def nameservers_flat=(separated_list)
+            servers = separated_list.strip.split(/\s*[,|:;\s]\s*/)
+            servers.each do |server|
+                server.strip!
+                p server
+                if not IPAddress.valid? server
+                    fail "One or more invalid IP addresses in nameserver list"
+                end
+            end
+            @nameservers = servers
+        end
+
+        def nameservers_flat
+            @nameservers.join(',')
+        end
+    end
+
+    # Dynamic IPv4 addressing via DHCP
+    class DHCPAddressing
+        def initialize(args={})
+            # we accept no args
+        end
+
+        def addressing_type
+            'dhcp'
+        end
+
+        def interfaces_lines
+            # DHCP needs no additional interfaces args 
+            # from the addressing side
+            []
+        end
+
+        def validate
+            # nothing to validate
+        end
+
+        def safe_assign
+            [] # no args
+        end
+
+        def args
+            { }
+        end
+
+        def write_configs
+            # dhclient will write our resolv.conf so we do not need 
+            # to do anything
+        end
+
+        def self.description
+            "Dynamic Addressing - DHCP"
+        end
+    end
+
+    # Read a JSON formatted network configuration from the config store.
+    # This instantiates the connection and addressing method classes
+    # and returns the instances i.e. cm, am = read_network_config
+	# 
+	# If no configuration is saved or it is corrupt this returns
+	# a default configuration that is somewhat likely to work.
+    def self.read_network_config
+		input = ConfigStore.read_config('network_config', '')
+
+		begin
+			args = JSON.parse(input)
+		rescue
+			# set up some sane defaults if we have no configuration
+			# or it can't be parsed
+			args = {
+				'connection_method' => 'WiredConnection',
+				'addressing_method' => 'DHCPAddressing',
+				'connection_method_args' => { },
+				'addressing_method_args' => { }
+			}
+		end
+
+        connection_method_class = ConcertoConfig.const_get(args['connection_method'])
+        addressing_method_class = ConcertoConfig.const_get(args['addressing_method'])
+
+        connection_method = connection_method_class.new(
+            args['connection_method_args']
+        )
+
+        addressing_method = addressing_method_class.new(
+            args['addressing_method_args']
+        )
+
+        return [connection_method, addressing_method]    
+    end
+
+	# Save the network configuration to the configuration store.
+	# Arguments are instances of connection method and addressing 
+	# method classes. Throws exception if either one is not valid.
+	def self.write_network_config(cm, am)
+		# Check that everything is consistent. If not, we currently throw
+		# an exception, which probably is not the best long term solution.
+		cm.validate
+		am.validate
+
+		# Serialize our instances as JSON data to be written to the config file.
+		json_data = {
+			'connection_method' => cm.class.basename,
+			'connection_method_args' => cm.args,
+			'addressing_method' => am.class.basename,
+			'addressing_method_args' => am.args
+		}.to_json
+		
+		# Save the serialized configuration.
+		ConfigStore.write_config('network_config', json_data)
+	end
+
+    # This reads a JSON configuration file on STDIN and writes the interfaces
+    # file. Also the classes instantiated will have a chance to write
+    # out any auxiliary files needed.
+    def self.configure_system_network
+        connection_method, addressing_method = read_network_config
+
+        ifname = connection_method.config_interface_name
+
+        # squirrel away the name of the interface we are configuring
+        # This will be useful later for getting network status information.
+		ConfigStore.write_config('network_interface', ifname)
+        
+        # Write the /etc/network/interfaces file.
+        File.open(INTERFACES_FILE, 'w') do |f|
+            f.puts "# Concerto Live network configuration"
+            f.puts "# Generated by netconfig.rb"
+            f.puts "# Changes will be lost on reboot"
+			f.puts "auto lo"
+			f.puts "iface lo inet loopback"
+			f.puts ""
+            f.puts "auto #{ifname}"
+            f.puts "iface #{ifname} inet #{addressing_method.addressing_type}"
+
+            addressing_method.interfaces_lines.each do |line|
+                f.puts "\t#{line}"
+            end
+
+            connection_method.interfaces_lines.each do |line|
+                f.puts "\t#{line}"
+            end
+        end
+
+        # Write auxiliary configuration files.
+        connection_method.write_configs
+    end
+
+    # Get the name of the interface we configured
+    def self.configured_interface
+		ifname = ConfigStore.read_config('network_interface', '')
+		if ifname != ''
+			Interface.new(ifname)
+		else
+			nil
+		end
+    end
+end

data/web/app.rb

@@ -0,0 +1,320 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'haml'
+require 'json'
+require 'net/http'
+require 'ipaddress'
+require 'netconfig'
+require 'sys/uptime'
+require 'sys/proctable'
+include Sys
+
+class ConcertoConfigServer < Sinatra::Base
+	# push these over to netconfig.rb?
+	# Our list of available physical-layer connection methods...
+	CONNECTION_METHODS = [ 
+		ConcertoConfig::WiredConnection, 
+		ConcertoConfig::WirelessConnection 
+	]
+	# ... and available layer-3 addressing methods.
+	ADDRESSING_METHODS = [ 
+		ConcertoConfig::DHCPAddressing, 
+		ConcertoConfig::StaticAddressing 
+	]
+
+	# Hosts we allow to access configuration without authenticating.
+	LOCALHOSTS = [ 
+		IPAddress.parse("127.0.0.1"), 
+		IPAddress.parse("::1") 
+	]
+
+	set :haml, { :format => :html5, :layout => :main }
+
+	helpers do
+		# Get the return value of the method on obj if obj supports the method.
+		# Otherwise return the empty string.
+		# This is useful in views where arguments may be of diverse types.
+		def value_from(obj, method)
+			if obj.respond_to? method
+				obj.send method
+			else
+				""
+			end
+		end
+
+		# Enforce authentication on actions.
+		# Calling from within an action will check authentication and return 
+		# 401 if unauthorized.
+		def protected!
+			unless authorized?
+				response['WWW-Authenticate'] = \
+					%(Basic realm="Concerto Configuration")
+				throw(:halt, [401, "Not authorized\n"])
+			end
+		end
+
+		# Check authorization credentials.
+		# Currently configured to check if the REMOTE_ADDR is local and allow
+		# everything if so. This permits someone at local console to configure
+		# without the need for a password. Others must have the correct 
+		# password to be considered authorized.
+		def authorized?
+			ip = IPAddress.parse(request.env['REMOTE_ADDR'])
+			password = ConcertoConfig::ConfigStore.read_config(
+				'password', 'default'
+			)
+			if LOCALHOSTS.include? ip
+				# allow all requests from localhost no questions asked
+				true
+			else
+				@auth ||= Rack::Auth::Basic::Request.new(request.env)
+				@auth.provided? && @auth.basic? && @auth.credentials && \
+					@auth.credentials == ['root', password]
+			end
+		end
+
+		# Get our base URL from wherever it may be stored.
+		def concerto_url
+			ConcertoConfig::ConfigStore.read_config('concerto_url', '')
+		end
+
+		# Try to figure out what our current IPv4 address is
+		# and return it as a string.
+		def my_ip
+			iface = ConcertoConfig.configured_interface
+			if iface
+				iface.ip
+			else
+				"Network setup failed or bad configuration"
+			end
+		end
+
+		# Check if we have something resembling a network connection.
+		# This means we found a usable interface and it has an IPv4 address.
+		def network_ok
+			iface = ConcertoConfig.configured_interface
+			if iface
+				if iface.ip != "0.0.0.0"
+					true
+				else
+					false
+				end
+			else
+				false
+			end
+		end
+
+		# Check if we can retrieve a URL and get a 200 status code.
+		def validate_url(url)
+			begin
+				# this will fail with Errno::something if server 
+				# can't be reached
+				response = Net::HTTP.get_response(URI(url))
+				if response.code != "200"
+					# also bomb out if we don't get an OK response
+					# maybe demanding 200 is too strict here?
+					fail
+				end
+
+				# if we get here we have a somewhat valid URL to go to
+				true
+			rescue
+				# our request bombed out for some reason
+				false
+			end
+		end
+	end
+
+	get '/' do
+	  if concerto_url == ''
+	    redirect '/setup'
+	  else
+	    redirect '/player_status'
+	  end
+	end
+
+	# The local fullscreen browser will go to /screen.
+	# We should redirect to the screen URL if possible.
+	# Otherwise, we need to go to the setup page to show useful information
+	# and allow for local configuration if needed/wanted.
+	get '/screen' do
+		# if we don't have a URL go to setup
+		# if we do, check it out
+		if concerto_url == ''
+			redirect '/setup'
+		else
+			# check if the concerto server is reachable, if so redirect there
+			# if not redirect to a local error message screen
+			if validate_url(concerto_url)
+				redirect concerto_url
+			else
+				redirect '/problem'
+			end
+		end
+	end
+
+	# Present a form for entering the base URL.
+	get '/setup' do
+		protected!
+		if network_ok
+			# Everything's up and running, we just don't know what 
+			# our URL should be.
+			haml :setup
+		else
+			# The network settings are not sane, we don't have an IP.
+			# Redirect the user to the network configuration page to 
+			# take care of this.
+			#redirect '/netconfig'
+		end
+	end
+
+	# Save the Concerto base URL.
+	post '/setup' do
+		protected!
+		url = params[:url]
+		if validate_url(url)
+			# save to the configuration store
+			ConcertoConfig::ConfigStore.write_config('concerto_url', url)
+
+			# root will now redirect to the proper concerto_url
+			redirect '/screen'
+		else
+			# the URL was no good, back to setup!
+			# error handling flash something something something
+			redirect '/setup'
+		end
+	end
+
+	# render a page indicating that the concerto_url is no good.
+	# this page redirects to / every 5 seconds
+	get '/problem' do
+		haml :problem
+	end
+
+	get '/netconfig' do
+		protected!
+
+		# parse existing config file (if any)
+		# if there isn't one, nil will suffice because our
+		# value_from(...) helper will return the empty string if a method
+		# is not implemented. This is also how we get away with just having
+		# one instance each of the config classes that are currently selected.
+		begin
+			cm, am = ConcertoConfig.read_network_config
+		rescue Errno::ENOENT
+			cm = nil
+			am = nil
+		end
+
+		# view will grab what it can from our existing 
+		# connection/addressing methods using value_from().
+		haml :netsettings, :locals => { 
+				:connection_method => cm, 
+				:addressing_method => am 
+			}
+	end
+
+	# Given the name of a class, pick a class out of a list of allowed classes.
+	# This is used for parsing the form input for network configuration.
+	def pick_class(name, list)
+		list.find { |klass| klass.basename == name }
+	end
+
+	# Extract arguments from a set of form data that are intended to go to a
+	# specific network configuration class. These fields have names of the form
+	# 'ClassName/field_name'; this function returns a hash in the form 
+	# { 'field_name' => 'value } containing the configuration arguments.
+	def extract_class_args(params, target_class)
+		result = { }
+		params.each do |key, value|
+			klass, arg = key.split('/', 2)
+			if klass == target_class
+				result[arg] = value
+			end
+		end
+
+		result
+	end
+
+	# Set the arguments on an instance of a given configuration class.
+	# This uses the safe_assign method that should be present in all 
+	# configuration classes to determine which values are allowed to be passed
+	# via form fields (i.e. which ones are subject to validation)
+	def do_assign(params, instance)
+		safe = instance.safe_assign
+
+		params.each do |param, value|
+			if safe.include? param.intern
+				instance.send((param + '=').intern, value)
+			end
+		end
+	end
+
+	# Process the form fields and generate a JSON network configuration file.
+	post '/netconfig' do
+		protected!
+
+		# First we find the connection-method and addressing-method classes.
+		cmclass = pick_class(params[:connection_type], CONNECTION_METHODS)
+		fail "Connection method not supported" if cmclass.nil?
+		
+		amclass = pick_class(params[:addressing_type], ADDRESSING_METHODS)
+		fail "Addressing method not supported" if amclass.nil?
+
+		# ... and create some instances of them.
+		cm = cmclass.new
+		am = amclass.new
+		
+		# Now given the names of the specific classes the user has chosen,
+		# extract the corresponding form fields.
+		cmargs = extract_class_args(params, cmclass.basename)
+		amargs = extract_class_args(params, amclass.basename)
+
+		# Set properties on each instance given the form values passed in.
+		do_assign(cmargs, cm)
+		do_assign(amargs, am)
+
+		# Save the configuration file.
+		ConcertoConfig.write_network_config(cm, am)
+
+		# Reload network configuration.
+		STDERR.puts "Trying to bring down the interface"
+		if ConcertoConfig.configured_interface
+			ConcertoConfig.configured_interface.ifdown
+		end
+		STDERR.puts "Rewriting configuration files"
+		ConcertoConfig::configure_system_network
+		STDERR.puts "Bringing interface back up"
+		ConcertoConfig.configured_interface.ifup
+
+		# Back to the network form.
+		redirect '/netconfig' # as a get request
+	end
+
+	get '/password' do
+		protected!
+		haml :password
+	end
+
+	post '/password' do
+		protected!
+		
+		if params[:newpass] != params[:newpass_confirm]
+			# something something error handling something
+			redirect '/password'
+		end
+		
+		ConcertoConfig::ConfigStore.write_config('password', params[:newpass])
+		redirect '/setup'
+	end
+	
+	#Shows uptime,firmware version, and general system and process information
+	#Requires ffi, sys-uptime, and sys-proctable gems
+	get '/player_status' do
+	  @proctable = ProcTable.ps
+	  haml :player_status
+	end	
+	
+end
+
+ConcertoConfigServer.run!

data/web/config.ru

@@ -0,0 +1,2 @@
+require './app.rb'
+run Sinatra::Application

data/web/public/network.js

@@ -0,0 +1,27 @@
+function show_hide(id_to_show, where) {
+    $(where).each(function(k, el) {
+        if ($(el).attr('id') == id_to_show) {
+            $(el).show( );
+        } else {
+            $(el).hide( );
+        }
+    });
+}
+
+function update_connection_type_fields() {
+    var id_to_show = $("#connection_type").val();
+    show_hide(id_to_show, "#connection div");
+}
+
+function update_address_type_fields() {
+    var id_to_show = $("#addressing_type").val();
+    show_hide(id_to_show, "#address div");
+}
+
+$(function() {
+    update_connection_type_fields( );
+    update_address_type_fields( );
+
+    $("#connection_type").change(update_connection_type_fields);
+    $("#addressing_type").change(update_address_type_fields);
+});

data/web/public/problem.js

@@ -0,0 +1,7 @@
+function redirect() {
+    window.location = '/screen';
+}
+
+$(function() {
+    setTimeout(redirect, 5000);
+})

data/web/public/stylesheet.css

@@ -0,0 +1,3 @@
+.error {
+    text-align: center;
+}

data/web/views/main.haml

@@ -0,0 +1,6 @@
+%htmlt
+    %head
+        %title="Concerto Player Network Configuration"
+        %script{:src=>"https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.js"}
+        %link{:rel=>"stylesheet", :type=>"text/css", :href=>"/stylesheet.css"}
+    %body=yield

data/web/views/netsettings.haml

@@ -0,0 +1,64 @@
+%script{:src=>"network.js"}
+%a{:href=>"/setup"}="Back to setup"
+%h1="Concerto Player Network Configuration"
+%form{:method=>"post"}
+    %h2="Connection Type"
+    %select#connection_type{:name=>"connection_type"}
+        / list out our available connection methods as options
+        / set the html selected flag on the one that is currently 
+        / selected in the config
+        - CONNECTION_METHODS.each do |cm|
+            %option{:value=>cm.basename,
+                :selected=>(cm==connection_method.class)}=cm.description
+    #connection
+        #WiredConnection
+            %h3="Wired Connection Settings"
+            %p
+                %label{:for=>"WiredConnection_interface_name"}="Interface Name"
+                %select#interface_name{:name=>"WiredConnection/interface_name"}
+                    %option{:value=>""}="Auto Select"
+                    / list out available interfaces and their MAC addresses
+                    / preselect one if there was one chosen in config
+                    - ConcertoConfig::WiredConnection.interfaces.each do |iface|
+                        %option{:value=>iface.name, :selected=>value_from(connection_method, :interface_name)==iface.name}="#{iface.name} - #{iface.mac}"
+        #WirelessConnection
+            %h3="Wireless Connection Settings (no encryption)"
+            %p
+                %label{:for=>"WirelessConnection_interface_name"}="Interface Name"
+                %select#interface_name{:name=>"WirelessConnection/interface_name"}
+                    %option{:value=>""}="Auto Select"
+                    / same as above but with the wireless interfaces
+                    - ConcertoConfig::WirelessConnection.interfaces.each do |iface|
+                        %option{:value=>iface.name, :selected=>value_from(connection_method, :interface_name) == iface.name}="#{iface.name} - #{iface.mac}"
+            %p
+                %label{:for=>"WirelessConnection_ssid"}="SSID"
+                %input{:type=>"text", :name=>"WirelessConnection/ssid", 
+                    :value=>value_from(connection_method, :ssid)}
+    %h2="IP Address"
+    %select#addressing_type{:name=>"addressing_type"}
+        - ADDRESSING_METHODS.each do |am|
+            %option{:value=>am.basename,
+                :selected=>(am==addressing_method.class)}=am.description
+    #address
+        #DHCPAddressing
+        #StaticAddressing
+            %h3="Static Address Settings"
+            %p
+                %label{:for=>"StaticAddressing_address"}="Address"
+                %input{:type=>"text", :name=>"StaticAddressing/address",
+                    :value=>value_from(addressing_method, :address)}
+            %p
+                %label{:for=>"StaticAddressing_netmask"}="Netmask"
+                %input{:type=>"text", :name=>"StaticAddressing/netmask", 
+                    :value=>value_from(addressing_method, :netmask)}
+            %p
+                %label{:for=>"StaticAddressing_gateway"}="Gateway"
+                %input{:type=>"text", :name=>"StaticAddressing/gateway", 
+                    :value=>value_from(addressing_method, :gateway)}
+            %p
+                %label{:for=>"StaticAddressing_address"}="Nameservers (separate with commas or spaces)"
+                %input{:type=>"text", :name=>"StaticAddressing/nameservers_flat", 
+                    :value=>value_from(addressing_method, :nameservers_flat)}
+
+    %input{:type=>"submit"}
+

data/web/views/password.haml

@@ -0,0 +1,9 @@
+%form{:method=>'post'}
+	%p
+		%label{:for=>'newpass'} New Password
+		%input{:type=>'password', :name=>'newpass'}
+	%p
+		%label{:for=>'newpass_confirm'} Confirm Password
+		%input{:type=>'password', :name=>'newpass_confirm'}
+	%p
+		%input{:type=>'submit', :value=>'Change Password'}

data/web/views/player_status.haml

@@ -0,0 +1,8 @@
+System Uptime: #{Uptime.uptime}
+
+System Processes:
+%br/
+- for p in @proctable
+  %b= p.comm
+  (PID #{p.pid.to_s})
+  %br/

data/web/views/problem.haml

@@ -0,0 +1,15 @@
+%script{:src=>"problem.js"}
+.error
+    %p
+        %img{:src=>"trollface.png"}
+
+    %h1 Problem?
+    %p 
+        Due to technical difficulties, this Concerto screen is currently not 
+        operational. Please check again soon.
+    %p
+        ==The Concerto installation at #{concerto_url} could not be reached.
+    %p
+        If the URL needs to be changed, go back to
+        %a{:href=>"/setup"}
+            Player Configuration

data/web/views/setup.haml

@@ -0,0 +1,25 @@
+%h1 Welcome to Concerto Player
+%p 
+	You're seeing this because your Concerto player has not yet been configured.
+	We need the URL of your Concerto instance before we can get up and running.
+
+%form{:method=>'post'}
+	%p
+		%label{:for=>'url'} URL
+		%input{:type=>'text', :name=>'url'}
+		%input{:type=>'submit', :value=>'Here it is!'}
+
+%p
+	The IPv4 address of this screen appears to be:
+	=my_ip
+%p
+	==This page can be accessed remotely via http://#{my_ip}/setup
+%p
+	Username is root, default password is 'default'.
+%p 
+	Also, you may want to
+	%a{:href=>'/netconfig'} change network settings
+	or
+	%a{:href=>'/password'} change the configuration password.
+	
+	

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: bandshell
+version: !ruby/object:Gem::Version
+  version: 0.0.8
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Armenia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sys-uptime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sys-proctable
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ipaddress
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Client-side tools for Concerto digital signage
+email: andrew@asquaredlabs.com
+executables:
+- concerto_netsetup
+- concerto_configserver
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/live_image.rb
+- lib/netconfig.rb
+- lib/config_store.rb
+- web/config.ru
+- web/app.rb
+- web/public/network.js
+- web/public/stylesheet.css
+- web/public/problem.js
+- web/public/trollface.png
+- web/views/main.haml
+- web/views/password.haml
+- web/views/setup.haml
+- web/views/netsettings.haml
+- web/views/problem.haml
+- web/views/player_status.haml
+- bin/concerto_configserver
+- bin/bandshell-daemon.rb
+- bin/concerto_netsetup
+- bin/bandshell-control.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Concerto Client Tools
+test_files: []