dewiring 0.1.2

data/lib/wire/model/loader.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # ProjectYamlLoader is able to load a model
+  # from yaml files (as written by init command)
+  class ProjectYamlLoader
+    # loads project model from target_dir
+    def load_project(target_dir)
+      # ensure target dir exists, is a dir
+      fail(ArgumentError, 'Nonexisting directory') unless File.exist?(target_dir) &&
+          File.directory?(target_dir)
+
+      # create project
+      project = Project.new(target_dir)
+
+      # iterate all model element types, load if file exists
+      MODEL_ELEMENTS.each do |model_element|
+        filename = File.join(target_dir, "#{model_element}.yaml")
+
+        # jump out unless file exists
+        next unless File.exist?(filename) && File.readable?(filename)
+
+        $log.debug "Loading model file #{filename}"
+
+        element_data = load_model_element_file(filename)
+        project.merge_element model_element, element_data
+      end
+
+      # dump some statistics
+      puts(project.calc_stats.reduce([]) do |res, elem|
+        type = elem[0]
+        count = elem[1]
+        res << "#{count} #{type}(s)"
+      end.join(', '))
+
+      project
+    end
+
+    # reads filename as yaml, returns elements
+    def load_model_element_file(filename)
+      YAML.load(File.open(filename, 'r'))
+    end
+  end
+end

data/lib/wire/model/network_validation.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # Run validations on network model part
+  class NetworksValidation < ValidationBase
+    # run validation steps on network elements
+    # returns:
+    # - nil, results in errors of ValidationBase
+    def run_validations
+      networks_attached_to_zones?
+      duplicate_networks_found?
+      missing_network_def_found?
+      nonmatching_hostips_found?
+      dhcp_address_ranges_valid?
+    end
+
+    # ensures that all networks are attached to a zone
+    def networks_attached_to_zones?
+      objects_attached_to_zones? 'networks'
+    end
+
+    # ensures that all network ranges are unique
+    def duplicate_networks_found?
+      dup_map = {}
+      @project.get_element('networks').each do |network_name, network_data|
+        nw = network_data[:network]
+        dupe_name = dup_map[nw]
+
+        mark("Network range #{nw} used in more than one network (#{dupe_name})",
+             'network', network_name) if dupe_name
+        dup_map.store nw, network_name
+      end
+    end
+
+    # ensures that all networks have their network range defined
+    def missing_network_def_found?
+      @project.get_element('networks').each do |network_name, network_data|
+        nw = network_data[:network]
+        mark("Network #{network_name} has no network ip range.",
+             'network', network_name) unless nw
+      end
+    end
+
+    # ensures that all networks with hostips have their hostip
+    # within the network range of its network, i.e. 10.10.1.1 for 10.10.1.0/24
+    def nonmatching_hostips_found?
+      @project.get_element('networks').each do |network_name, network_data|
+        network = network_data[:network]
+        host_ip = network_data[:hostip]
+        next unless network && host_ip
+
+        host_ip_ip = IPAddr.new(host_ip)
+        network_ip = IPAddr.new(network)
+
+        mark("Network Host ip #{host_ip} is not within network range" \
+          "#{network} of network #{network_name}", 'network', network_name) unless
+            host_ip_ip.in_range_of?(network_ip)
+      end
+    end
+
+    # ensures that if a network has dhcp set, its :start/:end address
+    # ranges are within the address range of network, and a hostip is
+    # given (for dnsmasq to udp-listen on it)
+    # rubocop:disable CyclomaticComplexity
+    def dhcp_address_ranges_valid?
+      @project.get_element('networks').each do |network_name, network_data|
+        network = network_data[:network]
+        dhcp_data = network_data[:dhcp]
+        next unless network && dhcp_data
+
+        # do we have a host-ip on this bridge?
+        host_ip = network_data[:hostip]
+        if !host_ip
+          mark("Network #{network_name} wants dhcp, but does not include a hostip.",
+               'network', network_name)
+          return false
+        else
+          if !dhcp_data[:start] || !dhcp_data[:end]
+            mark("Network #{network_name} wants dhcp, but does not include an " \
+                 'address range. Set :start, :end.',
+                 'network', network_name)
+            return false
+          else
+            # check ip ranges
+
+            begin
+              dhcp_start_ip = IPAddr.new(dhcp_data[:start])
+              dhcp_end_ip = IPAddr.new(dhcp_data[:end])
+              network_ip = IPAddr.new(network)
+
+              mark("Network dhcp start ip #{dhcp_data[:start]} is not within network range" \
+                "#{network} of network #{network_name}", 'network', network_name) unless
+                  dhcp_start_ip.in_range_of?(network_ip)
+
+              mark("Network dhcp end ip #{dhcp_data[:end]} is not within network range" \
+                "#{network} of network #{network_name}", 'network', network_name) unless
+                  dhcp_end_ip.in_range_of?(network_ip)
+            rescue => e
+              mark("Network dhcp ip range is not valid: #{e}", 'network', network_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wire/model/project.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # define model elements for lookup purposes
+  MODEL_ELEMENTS = %w( zones networks appgroups )
+
+  # Defines a project with model elements
+  # (zones, networks, ...) as open structs
+  class Project
+    # +target_dir+ is the directory where model files are stores
+    # +data+ is a [Hash] of all model objects
+    attr_accessor	:target_dir, :data
+
+    # set up empty project. Sets +target_dir+
+    def initialize(target_dir)
+      @target_dir = target_dir
+      @data = {}
+    end
+
+    # merge in hash data
+    # Params:
+    # +element_name+ Name of model element part, i.e. 'zones'
+    # +element_data+ [Hash] of model element data
+    def merge_element(element_name, element_data)
+      @data.merge!({ element_name.to_sym => element_data })
+    end
+
+    # check if we have a model element (i.e. zones)
+    # params:
+    # +element_name+ Name of model element part, i.e. 'backend-zone'
+    def element?(element_name)
+      @data.key? element_name.to_sym
+    end
+
+    # retrieve element hash, raise ArgumentError if
+    # it does not exist.
+    # params:
+    # +element_name+ Name of model element part, i.e. 'backend-zone'
+    def get_element(element_name)
+      fail(
+          ArgumentError, "Element #{element_name} not found"
+      ) unless element?(element_name)
+      @data[element_name.to_sym]
+    end
+
+    # calculates count statistics on project
+    # returns:
+    # - [Hash], key => element type, value => [int] count
+    def calc_stats
+      result = {}
+
+      @data.each do |element_name, element_data|
+        result[element_name] = element_data.size
+      end
+
+      result
+    end
+  end
+end

data/lib/wire/model/state.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+require 'singleton'
+
+# Wire module
+module Wire
+  # +State+ is a container for a state model
+  # :reek:DataClump
+  class State
+    # [Hash] of all +state+ entries, key=name, value=StateEntry
+    attr_accessor :state
+    # backref to project
+    attr_accessor :project
+    # did something change? since last change or load/save
+    attr_reader :changed
+
+    include Singleton
+
+    # creates an empty state
+    def initialize
+      clean
+    end
+
+    # cleans the state
+    def clean
+      @state = {}
+      # +changed+ indicates wether state has changed
+      @changed = false
+    end
+
+    # adds or updates state
+    # +type+ i.e. :bridge
+    # +name+ i.e. :br0
+    # +state+, one of :up, :down, :unknown
+    def update(type, name, state)
+      key = (make_key(type, name))
+      entry = @state[key]
+      if entry
+        (entry.state != state) && @changed = true
+        entry.state = state
+      else
+        @state.store(key, StateEntry.new(type, name, state))
+        @changed = true
+      end
+    end
+
+    # combines +type+ and +name+ into a key suitable for the hash
+    def make_key(type, name)
+      "%#{type}%#{name}"
+    end
+
+    # checks if we have a state for resource
+    # given by +type+ and +name+
+    def state?(type, name)
+      @state.key?(make_key(type, name))
+    end
+
+    # checks if +type+ resource +name+
+    # is in state +state_to_check+
+    def check(type, name, state_to_check)
+      key = (make_key(type, name))
+      entry = @state[key]
+      return entry.state == state_to_check if entry
+      false
+    end
+
+    # checks if resource +type+ +name+ is up
+    def up?(type, name)
+      check(type, name, :up)
+    end
+
+    # checks if resource +type+ +name+ is down
+    def down?(type, name)
+      check(type, name, :down)
+    end
+
+    # returns changed flad
+    def changed?
+      changed
+    end
+
+    # calls to_pretty_s on a state entries
+    def to_pretty_s
+      @state.reduce([]) do |arr, entry|
+        arr << entry[1].to_pretty_s
+      end.join(',')
+    end
+
+    # save current state to statefile (within project target dir)
+    def save
+      unless @changed
+        $log.debug 'Not saving state, nothing changed'
+        return
+      end
+      statefile_filename = state_filename
+      $log.debug "Saving state to #{statefile_filename}"
+      File.open(statefile_filename, 'w') do |file|
+        file.puts state.to_yaml
+      end
+      @changed = false
+    end
+
+    # load  state from statefile (within project target dir)
+    def load
+      statefile_filename = state_filename
+      if File.exist?(statefile_filename) &&
+          File.file?(statefile_filename) &&
+          File.readable?(statefile_filename)
+        $log.debug "Loading state from #{statefile_filename}"
+        @state = YAML.load_file(statefile_filename)
+      else
+        $log.debug 'No statefile found.'
+      end
+      @changed = false
+    end
+
+    # construct name of state file
+    def state_filename
+      File.join(@project.target_dir, '.state.yaml')
+    end
+  end
+
+  # A StateEntry combines a resource type,
+  # a resource and the state
+  class StateEntry
+    # +type+ i.e. :bridge
+    # +name+ i.e. :br0
+    # +state+, one of :up, :down, :unknown
+    attr_accessor :type, :name, :state
+
+    # initializes the state entry
+    # with given +type+ and +name+ and +state+
+    # sets :unknown state if +state+ not given
+    def initialize(type, name, state = :unknown)
+      self.type = type
+      self.name = name
+      self.state = state
+    end
+
+    # string representation
+    def to_s
+      "State:[type=#{type}, name=#{name}, state=#{state}]"
+    end
+
+    # readble string repr for output
+    def to_pretty_s
+      "#{type}:#{name} is #{state}"
+    end
+  end
+end

data/lib/wire/model/validation.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # raised in case of invalid model
+  class ValidationError
+    # +message+::   Validation Error message
+    # +element_type+::  Model element type of this error, i.e. 'Network'
+    # +element_name+::  Model element name
+    attr_accessor	:message, :element_type, :element_name
+
+    # Initializes the error object
+    # Params:
+    # +message+::   Validation Error message
+    # +element_type+::  Model element type of this error, i.e. 'Network'
+    # +element_name+::  Model element name
+    def initialize(message, element_type, element_name)
+      @message = message
+      @element_type = element_type
+      @element_name = element_name
+    end
+
+    # returns a string representation
+    def to_s
+      "ValidationError on #{@element_type} #{@element_name}: #{@message}"
+    end
+  end
+
+  # Validation Base class
+  class ValidationBase
+    # +errors+  Array of validation errors, see class ValidationError
+    attr_accessor	:errors
+
+    # initializes the Validation object on given +project+
+    def initialize(project)
+      @project = project
+      @errors = []
+    end
+
+    # adds a validation error to the error list
+    # +message+   Validation Error message
+    # +element_type+  Model element type of this error, i.e. 'Network'
+    # +element_name+  Model element name
+    def mark(message, element_type, element_name)
+      @errors << ValidationError.new(message, element_type, element_name)
+    end
+
+    # ensures that objects of given +type_as_string+ (i.e. networks)
+    # are attached to zones
+    def objects_attached_to_zones?(type_as_string)
+      zones = @project.get_element('zones')
+      @project.get_element(type_as_string).each do |name, data|
+        zone = data[:zone]    # assume that this object contains ref to a zone
+        if !zone
+          mark("#{type_as_string} is not attached to a zone", type_as_string, name)
+        else
+          mark("#{type_as_string} has invalid zone", type_as_string, name) unless zones.key?(zone)
+        end
+      end
+    end
+  end
+end

data/lib/wire/model/verification.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # raised in case of model elements
+  # not running or in other verification
+  # states
+  class VerificationError
+    # +message+:: verification (error) message
+    # +element_type+:: element type as string (i.e. 'network')
+    # +element_name+:: name of element within model
+    # +element+:: reference to model element
+    attr_accessor	:message, :element_type, :element_name, :element
+
+    # initalizes the verification error
+    # params:
+    # +message+:: verification (error) message
+    # +element_type+:: element type as string (i.e. 'network')
+    # +element_name+:: name of element within model
+    # +element+:: reference to model element
+    def initialize(message, element_type, element_name, element)
+      @message = message
+      @element_type = element_type
+      @element_name = element_name
+      @element = element
+    end
+
+    # string representation
+    def to_s
+      "VerificationError on #{@element_type} #{@element_name}: #{@message}"
+    end
+  end
+end

data/lib/wire/model.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+require_relative 'model/project.rb'
+require_relative 'model/loader.rb'
+require_relative 'model/validation.rb'
+require_relative 'model/network_validation.rb'
+require_relative 'model/appgroup_validation.rb'
+require_relative 'model/verification.rb'
+require_relative 'model/state.rb'

data/lib/wire/resource/bridge.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+include Wire::Execution
+
+# Wire module
+module Wire
+  # Resource module
+  module Resource
+    # Open vSwitch Bridge resource
+    class OVSBridge < ResourceBase
+      # +type+ of bridge (here: ovs)
+      # +executables+ [Hash] of binaries needed to control
+      # the resource
+      attr_accessor	:type, :executables
+
+      # initialize the bridge object with
+      # given +name+ and type
+      # params:
+      # - name	bridge name, i.e. "br0"
+      def initialize(name)
+        super(name)
+
+        # TODO: make configurable
+        @executables = {
+          :vsctl => '/usr/bin/ovs-vsctl'
+        }
+      end
+
+      # checks if the bridge exists
+      def exist?
+        LocalExecution.with(@executables[:vsctl],
+                            ['br-exists', @name]) do |exec_obj|
+          exec_obj.run
+          return (exec_obj.exitstatus != 2)
+        end
+      end
+
+      # checks if the bridge exists
+      def up?
+        exist?
+      end
+
+      # adds the bridge  (ovs-vsctl add-br)
+      def up
+        LocalExecution.with(@executables[:vsctl],
+                            ['add-br', @name]) do |up_exec_obj|
+          up_exec_obj.run
+          return (up_exec_obj.exitstatus == 0)
+        end
+      end
+
+      # checks if the bridge is down
+      def down?
+        !(up?)
+      end
+
+      # deletes the bridge (ovs-vsctl del-br)
+      def down
+        LocalExecution.with(@executables[:vsctl],
+                            ['del-br', @name]) do |down_exec_obj|
+          down_exec_obj.run
+          return (down_exec_obj.exitstatus == 0)
+        end
+      end
+
+      # Returns a string representation
+      def to_s
+        "Bridge:[#{name},type=#{type}]"
+      end
+    end
+  end
+end