dewiring 0.1.2

data/lib/wire/commands/updown_command_base.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # Base class for up/down commands
+  class UpDownCommand < BaseCommand
+    # generic method, calls run_on_project_zones for
+    # all zones in model
+    def run_on_project
+      zones = @project.get_element('zones')
+
+      # iterates all zones, descend into zone
+      # for further checks, mark all those bad
+      # zones, decide upon boolean return flag
+      (run_on_project_zones(zones)
+      .each do |_zone_name, zone_data|
+        # error occured in run_on_zone call. Lets mark this
+        zone_data.store :status, :failed
+
+      end.size > 0)
+    end
+
+    # run on all given +zones+
+    # Returns [Hash] of zones that failed.
+    def run_on_project_zones(zones)
+      zones.select do |zone_name, _|
+        $log.debug("Processing zone #{zone_name} ...")
+        run_on_zone(zone_name) == false
+      end
+    end
+
+    # if dhcp is part of given +network_data+, use
+    # +handler+ to process it.
+    # +zone_name+:: Name of zone
+    # +network_name+:: Name of network
+    def default_handle_dhcp(zone_name, network_name, network_data, handler)
+      dhcp_data = network_data[:dhcp]
+      return true unless dhcp_data
+
+      $log.debug 'Processing dhcp/dnsmasq ...'
+      handler.handle_dhcp(zone_name,
+                          network_name, network_data,
+                          dhcp_data[:start], dhcp_data[:end])
+    end
+
+    # if host ip is enabled for given network (+network_name+, +network_data+)
+    # use +handler+ to process it
+    def default_handle_hostip(network_name, network_data, handler)
+      hostip = network_data[:hostip]
+      return true unless hostip
+
+      $log.debug "Processing host ip on network #{network_name} ..."
+
+      # if the hostip is not in cidr, take netmask
+      # from network entry, add to hostip
+      hostip = ensure_hostip_netmask(hostip, network_data)
+
+      # forward to handler
+      handler.handle_hostip(network_name, hostip)
+    end
+
+    # returns networks from given +networks+ array that
+    # belong to +zone_name+
+    # params:
+    # +networks+:  array of all networks
+    # +zone_name+: name of desired zone
+    # returns:
+    # # => [Array] of networks for given zone
+    def self.get_networks_for_zone(networks, zone_name)
+      # select networks in given zone only
+      networks.select do |_, network_data|
+        network_data[:zone] == zone_name
+      end
+    end
+  end
+end

data/lib/wire/commands/validate_command.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
+  # Validate Command reads yaml, parses model elements
+  # and runs a number of consistency checks
+  class ValidateCommand < BaseCommand
+    # array of +errors+
+    attr_accessor :errors
+
+    # array of validations
+    attr_accessor :validations
+
+    # initializes an empty error list
+    def initialize
+      @errors = []
+      @validations = [NetworksValidation, AppGroupValidation]
+    end
+
+    # runs validation on given project
+    # returns
+    # => list of +errors+
+    def run_on_project
+      @errors = []
+
+      # run validations against it
+      # TODO: Move validation classes to class level definition
+      @validations.each do |val_clazz|
+        (@errors << run_validation(@project, val_clazz)).flatten!
+      end
+
+      if @errors.size == 0
+        outputs 'VALIDATE', 'OK, model is consistent.', :ok
+      else
+        outputs 'VALIDATE', 'ERROR, detected inconsistencies:', :error
+        @errors.each do |val_error|
+          outputs 'VALIDATE', val_error.to_s, :error
+        end
+      end
+
+      @errors
+    end
+
+    # run a validation of given +validation_class+ against
+    # the model
+    #
+    # params:
+    # +project+::           project model object, to validate
+    # +validation_class+::  class object of validation, i.e. NetworksValidation
+    #
+    # returns:
+    # list of errors from validation object
+    def run_validation(project, validation_class)
+      $log.debug "Running validation class #{validation_class}"
+      val_object = validation_class.new(project)
+      val_object.run_validations
+      val_object.errors
+    end
+  end
+end

data/lib/wire/commands/verify_command.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # Verify Command reads yaml, parses model elements
+  # and checks if given elements are present on the system
+  # rubocop:disable ClassLength
+  class VerifyCommand < BaseCommand
+    # +project+:: to operate upon
+    # +findings+:: is an array of potential errors that occured
+    # during verification run
+    attr_accessor :project, :findings
+    # allow to get access to handler object
+    attr_reader :handler
+
+    # set up with empty findings arraay
+    def initialize
+      @findings = []
+      @handler = VerifyCommandHandler.new
+    end
+
+    # add a finding to the findings array
+    # params:
+    # +msg+::           what went wrong
+    # +type+::          element type, i.e. Network
+    # +element_name+::  element_name
+    # +element_data+::  map of details, from model
+    def mark(msg, type, element_name, element_data)
+      @findings <<
+          VerificationError.new(msg, type,
+                                element_name, element_data)
+    end
+
+    # run verification on whole project
+    # iterates all zones, descend into zone
+    # verification
+    # returns:
+    # - [bool]  true = verification ok
+    def run_on_project
+      zones = @project.get_element('zones')
+
+      # iterates all zones, descend into zone
+      # for further checks, mark all those bad
+      # zones, decide upon boolean return flag
+      (run_on_project_zones(zones)
+        .each do |zone_name, zone_data|
+          # error occured in run_on_zone call. Lets mark this
+          zone_data.store :status, :failed
+          mark("Not all elements of zone \'#{zone_name}\' are valid.",
+               :zone, zone_name, zone_data)
+        end.size > 0)
+    end
+
+    # run verification on given +zones+
+    def run_on_project_zones(zones)
+      zones.select do |zone_name, _|
+        $log.debug("Verifying zone #{zone_name} ...")
+        b_zone_res = run_on_zone(zone_name)
+
+        if b_zone_res
+          outputs 'VERIFY', "Zone \'#{zone_name}\' verified successfully", :ok
+        else
+          outputs 'VERIFY', "Zone \'#{zone_name}\' NOT verified successfully", :err
+        end
+
+        b_zone_res == false
+      end
+    end
+
+    # run verification for given +zone_name+:
+    # - check if bridges exist for all networks in
+    #   this zone
+    def run_on_zone(zone_name)
+      networks = @project.get_element('networks')
+
+      b_verify_ok = true
+
+      # select networks in current zone only
+      networks_in_zone = networks.select do |_, network_data|
+        network_data[:zone] == zone_name
+      end
+      # verify these networks
+      b_verify_ok = false unless verify_networks(networks_in_zone, zone_name)
+
+      # select appgroups in this zone and verify them
+      appgroups_in_zone = objects_in_zone('appgroups', zone_name)
+      b_verify_ok = false unless verify_appgroups(appgroups_in_zone, zone_name)
+
+      b_verify_ok
+    end
+
+    # given an array of network elements (+networks_in_zone+), this
+    # method runs the verification on each network.
+    # It checks the availability of a bridge and
+    # the optional host ip on that bridge.
+    # Params:
+    # +networks_in_zone+:: Array of network data elements in desired zone
+    # +zone_name+:: Name of zone
+    def verify_networks(networks_in_zone, zone_name)
+      b_verify_ok = true
+      networks_in_zone.each do |network_name, network_data|
+        $log.debug("Verifying network \'#{network_name}\'")
+
+        bridge_name = network_name
+
+        $log.debug 'checking bridge ...'
+        # we should have a bridge with that name.
+        if @handler.handle_bridge(bridge_name) == false
+          network_data.store :status, :failed
+          b_verify_ok = false
+          mark("Bridge \'#{bridge_name}\' does not exist.",
+               :network, network_name, network_data)
+        else
+          network_data.store :status, :ok
+
+          hostip = network_data[:hostip]
+          # if we have a host ip, then that bridge should have
+          # this ip
+          if hostip
+            $log.debug 'checking host-ip ...'
+
+            # if the hostip is not in cidr, take netmask
+            # from network entry, add to hostip
+            hostip = ensure_hostip_netmask(hostip, network_data)
+
+            if @handler.handle_hostip(bridge_name, hostip) == false
+              network_data.store :status, :failed
+              b_verify_ok = false
+              mark("Host ip \'#{hostip}\' not up on bridge \'#{bridge_name}\'.",
+                   :network, network_name, network_data)
+            else
+              network_data.store :status, :ok
+            end
+          end
+
+          # if we have dhcp, check this
+          dhcp_data = network_data[:dhcp]
+          if dhcp_data
+            $log.debug 'checking dhcp ...'
+            if @handler.handle_dhcp(zone_name, network_name, network_data,
+                                    dhcp_data[:start],
+                                    dhcp_data[:end]) == false
+              network_data.store :status, :failed
+              b_verify_ok = false
+              mark("dnsmasq/dhcp not configured on network \'#{bridge_name}\'.",
+                   :network, network_name, network_data)
+            else
+              network_data.store :status, :ok
+            end
+          end
+        end
+      end
+      b_verify_ok
+    end
+
+    # Given a +zone_name+ and an array of +appgroups+ entries
+    # this methods verifies if these appgroups are up and running
+    # It also checks container's network attachments
+    def verify_appgroups(appgroups, zone_name)
+      b_verify_ok = true
+
+      appgroups.each do |appgroup_name, appgroup_data|
+        $log.debug("Verifying appgroup \'#{appgroup_name}\'")
+
+        if @handler.handle_appgroup(zone_name, appgroup_name,
+                                    appgroup_data, @project.target_dir) == false
+          appgroup_data.store :status, :failed
+          b_verify_ok = false
+          mark("Appgroup \'#{appgroup_name}\' does not run correctly.",
+               :appgroup, appgroup_name, appgroup_data)
+        else
+          appgroup_data.store :status, :ok
+        end
+
+        next unless b_verify_ok
+
+        zone_networks = objects_in_zone('networks', zone_name)
+        if @handler.handle_network_attachments(zone_name, zone_networks,
+                                               appgroup_name, appgroup_data,
+                                               @project.target_dir) == false
+          appgroup_data.store :status, :failed
+          b_verify_ok = false
+          mark("Appgroup \'#{appgroup_name}\' has missing network attachments",
+               :appgroup, appgroup_name, appgroup_data)
+        else
+          appgroup_data.store :status, :ok
+        end
+      end
+      b_verify_ok
+    end
+  end
+end

data/lib/wire/commands/verify_command_handler.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # handle_xxx methods for VerifyCommand
+  class VerifyCommandHandler < BaseCommand
+    # runs verification for a bridge resource identified by
+    # +bridge_name+
+    # Returns
+    # - [Bool] true if bridge exists
+    def handle_bridge(bridge_name)
+      bridge_resource = Wire::Resource::ResourceFactory.instance.create(:ovsbridge, bridge_name)
+      if bridge_resource.exist?
+        outputs 'VERIFY', "Bridge \'#{bridge_name}\' exists.", :ok
+        state.update(:bridge, bridge_name, :up)
+        return true
+      else
+        outputs 'VERIFY', "Bridge \'#{bridge_name}\' does not exist.", :err
+        state.update(:bridge, bridge_name, :down)
+        return false
+      end
+    end
+
+    # runs verification for a ip resource identified by
+    # +bridge_name+ and +host_ip+
+    # Returns
+    # - [Bool] true if hostip if up on bridge
+    def handle_hostip(bridge_name, hostip)
+      hostip_resource = Wire::Resource::ResourceFactory
+        .instance.create(:bridgeip, hostip, bridge_name)
+      if hostip_resource.up?
+        outputs 'VERIFY', "IP \'#{hostip}\' on bridge \'#{bridge_name}\' exists.", :ok
+        state.update(:hostip, hostip, :up)
+        return true
+      else
+        outputs 'VERIFY', "IP \'#{hostip}\' on bridge \'#{bridge_name}\' does not exist.", :err
+        state.update(:hostip, hostip, :down)
+        return false
+      end
+    end
+
+    # runs verification for dnsmasqs dhcp resource
+    # Returns
+    # - [Bool] true if dhcp setup is valid
+    def handle_dhcp(zone_name, network_name, network_entry, address_start, address_end)
+      resource = Wire::Resource::ResourceFactory
+        .instance.create(:dhcpconfig, "wire__#{zone_name}", network_name,
+                         network_entry, address_start, address_end)
+      if resource.up?
+        outputs 'VERIFY', "dnsmasq/dhcp config on network \'#{network_name}\' is valid.", :ok
+        state.update(:dnsmasq, network_name, :up)
+        return true
+      else
+        outputs 'VERIFY', "dnsmasq/dhcp config on network \'#{network_name}\' is not valid.", :err
+        state.update(:dnsmasq, network_name, :down)
+        return false
+      end
+    end
+
+    # runs verification for appgroups
+    # Returns
+    # - [Bool] true if appgroup setup is ok
+    def handle_appgroup(_zone_name, appgroup_name, appgroup_entry, target_dir)
+      # get path
+      controller_entry = appgroup_entry[:controller]
+
+      if controller_entry[:type] == 'fig'
+        fig_path = File.join(File.expand_path(target_dir), controller_entry[:file])
+
+        resource = Wire::Resource::ResourceFactory
+          .instance.create(:figadapter, "#{appgroup_name}", fig_path)
+        if resource.up?
+          outputs 'VERIFY', "appgroup \'#{appgroup_name}\' is running.", :ok
+          state.update(:appgroup, appgroup_name, :up)
+          return true
+        else
+          outputs 'VERIFY', "appgroup \'#{appgroup_name}\' is not running.", :err
+          state.update(:appgroup, appgroup_name, :down)
+          return false
+        end
+      end
+
+      $log.error "Appgroup not handled, unknown controller type #{controller_entry[:type]}"
+      false
+    end
+
+    # runs verification for container network attachment
+    # Params:
+    # ++_zone_name++: Name of zone
+    # ++networks++: Array of networks names, what to attach
+    # ++appgroup_name++: Name of appgroup
+    # ++appgroup_entry++: appgroup hash
+    # ++target_dir++: project target dir
+    # Returns
+    # - [Bool] true if appgroup setup is ok
+    def handle_network_attachments(_zone_name, networks, appgroup_name,
+                                   appgroup_entry, target_dir)
+      # query container ids of containers running here
+      # get path
+      controller_entry = appgroup_entry[:controller]
+
+      container_ids = []
+
+      if controller_entry[:type] == 'fig'
+        fig_path = File.join(File.expand_path(target_dir), controller_entry[:file])
+
+        resource = Wire::Resource::ResourceFactory
+        .instance.create(:figadapter, "#{appgroup_name}", fig_path)
+
+        container_ids = resource.up_ids || []
+        $log.debug "Got #{container_ids.size} container id(s) from adapter"
+      end
+
+      #
+      resource = Wire::Resource::ResourceFactory
+      .instance.create(:networkinjection, appgroup_name, networks.keys, container_ids)
+      if resource.up?
+        outputs 'VERIFY', "appgroup \'#{appgroup_name}\' has network(s) " \
+        "\'#{networks.keys.join(',')}\' attached.", :ok
+        state.update(:appgroup, appgroup_name, :up)
+        return true
+      else
+        outputs 'VERIFY', "appgroup \'#{appgroup_name}\' does not have " \
+        "all networks \'#{networks.keys.join(',')}\' attached.", :err
+        state.update(:appgroup, appgroup_name, :down)
+        return false
+      end
+    end
+  end
+end

data/lib/wire/commands.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+require_relative 'commands/base_command.rb'
+require_relative 'commands/init_command.rb'
+require_relative 'commands/init_interactive.rb'
+require_relative 'commands/validate_command.rb'
+require_relative 'commands/verify_command.rb'
+require_relative 'commands/verify_command_handler.rb'
+require_relative 'commands/spec_command.rb'
+require_relative 'commands/spec_templates.rb'
+require_relative 'commands/updown_command_base.rb'
+require_relative 'commands/up_command.rb'
+require_relative 'commands/up_command_handler.rb'
+require_relative 'commands/down_command.rb'
+require_relative 'commands/down_command_handler.rb'

data/lib/wire/common.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+require 'thor'
+
+require 'rainbow'
+require 'rainbow/ext/string'
+
+require 'yaml'
+require 'pp'
+require 'English'
+require 'erb'
+require 'tempfile'
+
+# set up log object
+require 'logger'
+
+$log = Logger.new STDOUT
+# parametrize
+$log.formatter = proc do |severity, _, _, msg|
+  "#{severity}  #{msg}\n"
+end
+$log.level = Logger::INFO
+
+# define exit codes
+module Wire
+  # central place for exit codes, given by +id+
+  # Params
+  # +id+ i.e. :init_bad_input
+  # Returns
+  # exitcode as [int]
+  def self.cli_exitcode(id)
+    codes = {
+      :init_bad_input	=> 10,
+      :init_dir_error => 20
+    }
+    codes[id]
+  end
+end

data/lib/wire/execution/local_exec.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+require 'singleton'
+
+# Wire module
+module Wire
+  # Execution module for executing commands
+  module Execution
+    # return singleton object
+    def self.global_execution_options
+      ExecutionOptions.singleton
+    end
+
+    # Global execution options, such as noop mode etc.
+    class ExecutionOptions
+      include Singleton
+
+      # set default execution options
+      def initialize
+        @options = { :b_noop => false }
+      end
+
+      # returns
+      # - [Boolean] true if no_op mode
+      def noop?
+        @options[:b_noop]
+      end
+    end
+
+    # Able to execute commands locally
+    # supports sudo and shell wrapping
+    class LocalExecution
+      # +exitstatus+  the exit status of a command that we ran
+      # +stdout+ stdout from command as [String]
+      # +stderr+ stderr from command as [String]
+      attr_accessor :exitstatus, :stdout, :stderr
+
+      # params:
+      # - command: binary to execute
+      # - args: optional cmd line arguments (exec array)
+      # - options:
+      #   - b_shell: if true, run as /bin/sh -c '<command> [args]'
+      #   - b_sudo: insert sudo if true
+      def initialize(command, args = nil, options =
+          { :b_shell => true, :b_sudo => true })
+        @command = command
+        @args = array_or_nil_as_str(args)
+        @options = options
+      end
+
+      # block-style. Creates a LocalExecution object with
+      # given parameters, yields it into a given block.
+      # Params:
+      # +command+ Command string, usually the binary
+      # +args+    argument array
+      # +options+ option map (b_shell, b_sudo flags)
+      # Yields
+      # - LocalExecution object
+      def self.with(command, args = nil, options =
+          { :b_shell => true, :b_sudo => true })
+        obj = LocalExecution.new command, args, options
+        yield obj
+      end
+
+      # constructs the single command line string from
+      # given parameters.
+      # Returns
+      # - Command line as [String]
+      def construct_command
+        cmd_arr = []
+        command_args = "#{@command} #{@args}".strip
+        sudo_str = (@options[:b_sudo] ? 'sudo ' : '')
+        if @options[:b_shell]
+          cmd_arr << '/bin/sh'
+          cmd_arr << '-c'
+
+          cmd_arr << "'#{sudo_str}#{command_args}'"
+        else
+          cmd_arr << "#{sudo_str}#{command_args}"
+        end
+
+        cmd_arr.join(' ').strip
+      end
+
+      # runs the command
+      # sets instance variables
+      # stdout, stderr, exitstatus
+      def run
+        cmd = construct_command
+
+        $log.debug "Executing #{cmd}"
+        @stdout = `#{cmd}`
+        @stderr = nil
+        @exitstatus = $CHILD_STATUS.exitstatus
+      end
+
+      private
+
+      # converts given +array_or_nil+ object to identity
+      # if array or an empty array if nil
+      def array_or_nil_as_str(array_or_nil)
+        (array_or_nil || []).join(' ')
+      end
+    end
+  end
+end

data/lib/wire/execution.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+require_relative 'execution/local_exec.rb'

data/lib/wire/model/appgroup_validation.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # Run validations on appgroup model part
+  class AppGroupValidation < ValidationBase
+    # run validation steps on appgroup elements
+    # returns
+    # - nil, results in errors of ValidationBase
+    def run_validations
+      return unless @project.element?('appgroups')
+
+      appgroups_attached_to_zones?
+      controllers_valid?
+    end
+
+    # ensures that all application groups are attached to a zone
+    def appgroups_attached_to_zones?
+      objects_attached_to_zones? 'appgroups'
+    end
+
+    # ensures that all application groups have a known controller
+    def controllers_valid?
+      @project.get_element('appgroups').each do |appgroup_name, appgroup_data|
+        controller_data = appgroup_data[:controller]
+        type = 'appgroup'
+        name = appgroup_name
+        if !controller_data
+          mark('Appgroup is not attached to a zone', type, name)
+        else
+          type = controller_data[:type]
+          mark('Appgroup controller does not have a type', type, name) unless type && type.size > 0
+
+          known_types = %w(fig)
+          mark('Appgroup controller has an unkown type (#{type})',
+               type, name) unless known_types.include?(type)
+        end
+      end
+    end
+  end
+end