concerto_client 0.0.1

data/bin/concerto_configserver

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

data/bin/concerto_netsetup

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

data/lib/concerto_client/application/app.rb

@@ -0,0 +1,312 @@
+require 'rubygems'
+require 'sinatra'
+require 'haml'
+require 'json'
+require 'net/http'
+require 'ipaddress'
+require 'concerto_client/netconfig'
+
+class ConcertoConfigServer < Sinatra::Base
+	# Some files we will use. None of these need to exist right away.
+	PASSWORD_FILE='/tmp/concerto_password'
+	URL_FILE='/tmp/concerto_url'
+
+	# 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") 
+	]
+
+	# Load our (constant) password from file.
+	begin
+		PASSWORD = File.open(PASSWORD_FILE) do |f|
+			f.readline.chomp
+		end
+	rescue Errno::ENOENT
+		PASSWORD = 'default'
+	end
+
+	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 localhost 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'])
+			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
+			begin
+				File.open(URL_FILE) do |f|
+					f.readline.chomp
+				end
+			rescue
+				""
+			end
+		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
+
+	# 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, :layout => :main
+		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)
+			File.open(URL_FILE, 'w') do |f|
+				f.write url
+			end
+			
+			# 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, :layout => :main
+	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_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 
+			},
+			:format => :html5, :layout => :main
+	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)
+
+		# 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' => cmclass.basename,
+			'connection_method_args' => cm.args,
+			'addressing_method' => amclass.basename,
+			'addressing_method_args' => am.args
+		}
+
+		# Write the config file to disk.
+		File.open(ConcertoConfig::CONFIG_FILE, 'w') do |f|
+			f.write json_data.to_json
+		end
+
+		# 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
+		STDERR.puts "Bringing interface back up"
+		ConcertoConfig.configured_interface.ifup
+
+		# Back to the network form.
+		redirect '/netconfig' # as a get request
+	end
+end
+
+ConcertoConfigServer.run!

data/lib/concerto_client/application/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/lib/concerto_client/application/public/problem.js

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

data/lib/concerto_client/application/public/stylesheet.css

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

data/lib/concerto_client/application/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/lib/concerto_client/application/views/netsettings.haml

@@ -0,0 +1,63 @@
+%script{:src=>"network.js"}
+%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/lib/concerto_client/application/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/lib/concerto_client/application/views/setup.haml

@@ -0,0 +1,18 @@
+%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'.

data/lib/concerto_client/netconfig.rb

@@ -0,0 +1,522 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'json'
+require 'ipaddress'
+
+# 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
+    def basename
+        name.gsub(/^.*::/, '')
+    end
+end
+
+module ConcertoConfig
+    # Where we store the name of the interface we are going to configure.
+    INTERFACE_FILE='/tmp/concerto_configured_interface'
+
+    # The Debian interfaces configuration file we are going to write out.
+    INTERFACES_FILE='/etc/network/interfaces'
+
+    # The configuration file we will read from.
+    CONFIG_FILE='/live/image/netconfig.json'
+
+    # 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 an input stream.
+    # This instantiates the connection and addressing method classes
+    # and returns the instances
+    # i.e.
+    # cm, am = read_config(STDIN)
+    def self.read_config
+		begin
+			input = IO.read(CONFIG_FILE)
+			args = JSON.parse(input)
+		rescue Errno::ENOENT
+			# set up some sane defaults if the config file doesn't exist
+			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
+
+    # 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
+        connection_method, addressing_method = read_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.
+        File.open(INTERFACE_FILE, 'w') do |f|
+            f.write ifname
+        end
+        
+        # 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 #{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
+        begin
+            ifname = File.open(INTERFACE_FILE) do |f|
+                f.readline.chomp
+            end
+            Interface.new(ifname)
+        rescue
+            nil
+        end
+    end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: concerto_client
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Armenia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-12 00:00:00.000000000Z
+dependencies: []
+description: Client-side tools for Concerto digital signage
+email: andrew@asquaredlabs.com
+executables:
+- concerto_netsetup
+- concerto_configserver
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/concerto_client/netconfig.rb
+- lib/concerto_client/application/app.rb
+- lib/concerto_client/application/public/network.js
+- lib/concerto_client/application/public/stylesheet.css
+- lib/concerto_client/application/public/problem.js
+- lib/concerto_client/application/public/trollface.png
+- lib/concerto_client/application/views/main.haml
+- lib/concerto_client/application/views/setup.haml
+- lib/concerto_client/application/views/netsettings.haml
+- lib/concerto_client/application/views/problem.haml
+- bin/concerto_configserver
+- bin/concerto_netsetup
+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.6
+signing_key: 
+specification_version: 3
+summary: Concerto Client Tools
+test_files: []