dewiring 0.1.2

data/lib/wire/cli/main_cli.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # WireCLI
+  # thor command line class
+  #
+  class WireCLI < Thor
+    # treat as non-thor commands
+    no_commands do
+      # pre-build array of available commands
+      def initialize_commands
+        @wire_commands = Wire::WireCommands.new
+      end
+
+      def apply_globals
+        options[:nocolor] && Rainbow.enabled = false
+        options[:debug] && $log.level = Logger::DEBUG
+      end
+
+    end
+
+    # set global options
+    class_option :nocolor, { :desc => 'Disable coloring in output',
+                             :required => false, :banner => '' }
+    class_option :debug, { :desc => 'Show debug output', :banner => '' }
+
+    desc 'init [TARGETDIR]', 'create an inital model in TARGETDIR'
+    long_desc <<-LONGDESC
+      Creates TARGETDIR if necessary, opens an interactive
+      console dialog about the model to be created.
+
+      Writes model files to TARGETDIR.
+    LONGDESC
+    # init method, run init in +target_dir+
+    def init(target_dir = '.')
+      initialize_commands
+      apply_globals
+      @wire_commands.run_init(target_dir)
+    end
+
+    # validate
+    #
+    desc 'validate [TARGETDIR]',
+         'read model in TARGETDIR and validate its consistency'
+    long_desc <<-LONGDESC
+      Given a model in TARGETDIR, the validate commands reads
+      the model and runs consistency checks against the model elements,
+      i.e. if every network is attached to a zone.
+    LONGDESC
+    # validate method, run model validation in +target_dir+
+    def validate(target_dir = '.')
+      initialize_commands
+      apply_globals
+      @wire_commands.run_validate(target_dir)
+    end
+
+    # verify
+    #
+    desc 'verify [TARGETDIR]',
+         'read model in TARGETDIR and verify against current system'
+    long_desc <<-LONGDESC
+      Given a model in TARGETDIR, the verify commands reads
+      the model and runs checks to see if everthing in the model
+      is present in the current system.
+    LONGDESC
+    # verify method, run model verification in +target_dir+
+    def verify(target_dir = '.')
+      initialize_commands
+      apply_globals
+      @wire_commands.run_verify(target_dir)
+    end
+
+    # spec
+    #
+    desc 'spec [TARGETDIR]',
+         'read model in TARGETDIR and create a serverspec' \
+         'specification example in TARGETDIR'
+    long_desc <<-LONGDESC
+      Given a model in TARGETDIR, the verify commands reads
+      the model. For each element it creates a serverspec-conformant
+      describe()-block in a spec file.
+      Writes spec helpers if they do not exist.
+    LONGDESC
+    option :run, { :desc => 'Automatically run serverspec', :banner => '', :type => :boolean }
+    # spec method, generate and optionally run serverspec in +target_dir+
+    def spec(target_dir = '.')
+      initialize_commands
+      apply_globals
+      @wire_commands.run_spec(target_dir, options[:run])
+    end
+
+    # up
+    #
+    desc 'up [TARGETDIR]',
+         'read model in TARGETDIR and bring system up' \
+         'according to model elements in TARGETDIR'
+    long_desc <<-LONGDESC
+      Given a model in TARGETDIR, the up commands reads
+      the model. Each model element is brought to live.
+    LONGDESC
+    # up method, bring model in +target_dir+ up
+    def up(target_dir = '.')
+      initialize_commands
+      apply_globals
+      @wire_commands.run_up(target_dir)
+    end
+
+    # down
+    #
+    desc 'down [TARGETDIR]',
+         'read model in TARGETDIR and bring system down' \
+         'according to model elements in TARGETDIR'
+    long_desc <<-LONGDESC
+      Given a model in TARGETDIR, the up commands reads
+      the model. Each model element is stopped and removed.
+    LONGDESC
+    # down method, bring model in +target_dir+ down
+    def down(target_dir = '.')
+      initialize_commands
+      apply_globals
+      @wire_commands.run_down(target_dir)
+    end
+  end
+end

data/lib/wire/cli.rb

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

data/lib/wire/commands/base_command.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # (Empty) Base command
+  class BaseCommand
+    # +params+ object and +project+ to operate upon
+    attr_accessor :params, :project
+
+    # returns the state object
+    def state
+      State.instance
+    end
+
+    # debugs a single line state
+    def dump_state
+      $log.debug "State: [#{state.to_pretty_s}]"
+    end
+
+    # +outputs+ writes a message to stdout, in given style
+    #
+    # params:
+    # +type+  1st column as type, i.e. "model" or "network" or "OK"
+    # +msg+   message to print
+    # +style+ coloring etc, supported:
+    #         :plain (default), :err (red), :ok (green)
+    # return
+    # - nil
+    #
+    # :reek:ControlParameter
+    def outputs(type, msg, style = :plain)
+      line = "#{type}> #{msg}"
+      line = line.color(:red) if (style == :err) || (style == :error)
+      line = line.color(:green) if style == :ok
+      line = line.color(:cyan) if style == :ok2
+
+      $stdout.puts line
+    end
+
+    # Issues a warning if we do not run as root.
+    def check_user
+      (ENV['USER'] != 'root') &&
+          $log.warn("Not running as root. Make sure user #{ENV['USER']} has sudo configured.")
+    end
+
+    # retrieve all objects of given +type_name+ in
+    # zone (by +zone_name+)
+    # returns:
+    # [Hash] of model subpart with elements of given type
+    def objects_in_zone(type_name, zone_name)
+      return {} unless @project.element?(type_name)
+      objects = @project.get_element type_name || {}
+      objects.select { |_, data| data[:zone] == zone_name }
+    end
+
+    # runs the command, according to parameters
+    # loads project into @project, calls run_on_project
+    # (to be defined in subclasses)
+    # params
+    # +params+  command parameter map, example key i.e. "target_dir"
+    def run(params = {})
+      check_user
+
+      @params = params
+      target_dir = @params[:target_dir]
+      outputs 'model', "Loading model in #{target_dir}"
+
+      # load it first
+      begin
+        loader = ProjectYamlLoader.new
+        @project = loader.load_project(target_dir)
+
+        # try to load state file.
+        state.project = @project
+        handle_state_load
+
+        run_on_project
+
+        $log.debug? && pp(@project)
+
+        handle_state_save
+
+      rescue => load_execption
+        $stderr.puts "Unable to process project model in #{target_dir}"
+        $log.debug? && puts(load_execption.inspect)
+        $log.debug? && puts(load_execption.backtrace)
+
+        return false
+      end
+      true
+    end
+
+    # if the hostip is not in cidr, take netmask
+    # from network entry, add to hostip
+    # params:
+    # +host_ip+ i.e. 192.168.10.1
+    # +network_data+ network data object, to take netmask from :network element
+    def ensure_hostip_netmask(host_ip, network_data)
+      return host_ip  if host_ip =~ /[0-9\.]+\/[0-9]+/
+
+      match_data = network_data[:network].match(/[0-9\.]+(\/[0-9]+)/)
+      if match_data && match_data.size >= 2
+        netmask = match_data[1]
+        $log.debug "Adding netmask #{netmask} to host-ip #{host_ip}"
+        return "#{host_ip}#{netmask}"
+      else
+        $log.error "host-ip #{host_ip} is missing netmask, and none given in network."
+        return host_ip
+      end
+    end
+
+    private
+
+    # Save state to state file
+    def handle_state_save
+      # dump state
+      $log.debug? && dump_state
+      state.save
+    rescue => save_exception
+      $stderr.puts "Error saving state, #{save_exception}"
+      $log.debug? && puts(save_exception.inspect)
+      $log.debug? && puts(save_exception.backtrace)
+    end
+
+    def handle_state_load
+      state.load
+      # dump state
+      $log.debug? && dump_state
+    rescue => load_exception
+      $stderr.puts "Error loading state, #{load_exception}"
+      $log.debug? && puts(load_exception.inspect)
+      $log.debug? && puts(load_exception.backtrace)
+    end
+  end
+end

data/lib/wire/commands/down_command.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # DownCommand reads yaml, parses model elements
+  # and brings all defined model elements "down", that is
+  # stopping and removing bridges, containers etc.
+  # - :target_dir
+  class DownCommand < UpDownCommand
+    # allow to get access to handler object
+    attr_reader :handler
+
+    # initializes DownCommand, creates handler
+    def initialize
+      super
+      @handler = DownCommandHandler.new
+    end
+
+    # run in given zone:
+    # returns:
+    # - bool: true if successful, false otherwise
+    def run_on_zone(zone_name)
+      b_result = true
+
+      networks = @project.get_element('networks')
+
+      # select appgroups in this zone and take them down first
+      appgroups_in_zone = objects_in_zone('appgroups', zone_name)
+      appgroups_in_zone.each do |appgroup_name, appgroup_data|
+        $log.debug("Processing appgroup \'#{appgroup_name}\'")
+
+        # process network attachments
+        zone_networks = objects_in_zone('networks', zone_name)
+        success = handler.handle_network_attachments(zone_name, zone_networks,
+                                                     appgroup_name, appgroup_data,
+                                                     @project.target_dir)
+        b_result &= success
+
+        # then take down containers
+        success = handler.handle_appgroup(zone_name,
+                                          appgroup_name, appgroup_data,
+                                          @project.target_dir)
+        b_result &= success
+
+      end
+
+      # select networks in current zone only
+      networks_in_zone = UpDownCommand.get_networks_for_zone(networks, zone_name)
+      networks_in_zone.each do |network_name, network_data|
+        $log.debug("Bringing down network #{network_name}")
+
+        # if we have dhcp, unconfigure dnsmasq
+        b_result &= default_handle_dhcp(zone_name, network_name, network_data, @handler)
+
+        # if we have a host ip on that bridge, take it down first
+        b_result &= default_handle_hostip(network_name, network_data, @handler)
+
+        # we should have a bridge with that name.
+        success = @handler.handle_bridge(network_name)
+        b_result &= success
+      end
+      b_result
+    end
+  end
+end

data/lib/wire/commands/down_command_handler.rb

@@ -0,0 +1,199 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # implements handle_xxx methods for DownCommand
+  # rubocop:disable ClassLength
+  class DownCommandHandler < BaseCommand
+    # take bridge down
+    def handle_bridge(bridge_name)
+      bridge_resource = Wire::Resource::ResourceFactory.instance.create(:ovsbridge, bridge_name)
+      if bridge_resource.down?
+        outputs 'DOWN', "Bridge #{bridge_name} already down.", :ok2
+        return true
+      end
+
+      bridge_resource.down
+      if bridge_resource.down?
+        outputs 'DOWN', "Bridge #{bridge_name} down/removed.", :ok
+        state.update(:bridge, bridge_name, :down)
+      else
+        outputs 'DOWN', "Error bringing down bridge #{bridge_name}.", :err
+        b_result = false
+      end
+
+      b_result
+    end
+
+    # remove ip from bridge interface
+    def handle_hostip(bridge_name, hostip)
+      b_result = true
+
+      bridge_resource = Wire::Resource::ResourceFactory.instance.create(:ovsbridge, bridge_name)
+      if bridge_resource.down?
+        outputs 'DOWN', "Bridge #{bridge_name} already down, will not care about ip", :ok2
+        return true
+      end
+
+      # we should have a bridge with that name.
+      hostip_resource = Wire::Resource::ResourceFactory
+      .instance.create(:bridgeip, hostip, bridge_name)
+      if hostip_resource.down?
+        outputs 'DOWN', "IP #{hostip} on bridge #{bridge_name} already down.", :ok2
+        return
+      end
+
+      hostip_resource.down
+      if hostip_resource.down?
+        outputs 'DOWN', "IP #{hostip} on bridge #{bridge_name} down/removed.", :ok
+        state.update(:hostip, hostip, :down)
+      else
+        outputs 'DOWN', "Error taking down ip #{hostip} on bridge #{bridge_name}.", :err
+
+        b_result = false
+      end
+
+      b_result
+    end
+
+    # unconfigures dnsmasq for dhcp
+    # params:
+    # +zone_name+ name of zone
+    # +network_name+ name of network (and bridge)
+    # +network+ network entry
+    # +address_start+ start of address range (i.e.192.168.10.10)
+    # +address_end+ end of dhcp address range (i.e.192.168.10.100)
+    # Returns
+    # - [Bool] true if dhcp setup is valid
+    def handle_dhcp(zone_name, network_name, network_entry, address_start, address_end)
+      resource_dhcp = Wire::Resource::ResourceFactory
+      .instance.create(:dhcpconfig, "wire__#{zone_name}", network_name,
+                       network_entry, address_start, address_end)
+      if resource_dhcp.down?
+        outputs 'DOWN', "dnsmasq/dhcp config on network \'#{network_name}\' is already down.", :ok2
+        return true
+      end
+
+      resource_dhcp.down
+      if resource_dhcp.down?
+        outputs 'DOWN', "dnsmasq/dhcp config on network \'#{network_name}\' is down.", :ok
+        state.update(:dnsmasq, network_name, :down)
+        return true
+      else
+        outputs 'DOWN', 'Error unconfiguring dnsmasq/dhcp ' \
+        "config on network \'#{network_name}\'.", :err
+        return false
+      end
+    end
+
+    # take the appgroups' controller and directs methods to
+    # it. First checks if appgroup is down. If so, ok. If not, take it down
+    # and ensure that it's down
+    # Params:
+    # +zone_name+:: Name of zone
+    # +appgroup_name+:: Name of Appgroup
+    # +appgroup_entry+:: Appgroup data from model
+    # +target_dir+:: Target directory (where fig file is located)
+    def handle_appgroup(zone_name, appgroup_name, appgroup_entry, target_dir)
+      # get path
+      controller_entry = appgroup_entry[:controller]
+
+      if controller_entry[:type] == 'fig'
+        return handle_appgroup__fig(zone_name, appgroup_name, appgroup_entry, target_dir)
+      end
+
+      $log.error "Appgroup not handled for zone #{zone_name}, " \
+      "unknown controller type #{controller_entry[:type]}"
+      false
+    end
+
+    # implement appgroup handling for fig controller
+    # Params:
+    # +zone_name+:: Name of zone
+    # +appgroup_name+:: Name of Appgroup
+    # +appgroup_entry+:: Appgroup data from model
+    # +target_dir+:: Target directory (where fig file is located)
+    def handle_appgroup__fig(zone_name, appgroup_name, appgroup_entry, target_dir)
+      # get path
+      controller_entry = appgroup_entry[:controller]
+
+      fig_path = File.join(File.expand_path(target_dir), controller_entry[:file])
+
+      resource_fig = Wire::Resource::ResourceFactory
+      .instance.create(:figadapter, "#{appgroup_name}", fig_path)
+
+      if resource_fig.down?
+        outputs 'DOWN', "appgroup \'#{appgroup_name}\' for zone #{zone_name} is already down.", :ok2
+        return true
+      end
+
+      b_result = false
+      resource_fig.down
+      if resource_fig.down?
+        outputs 'DOWN', "appgroup \'#{appgroup_name}\' for zone #{zone_name} is down.", :ok
+        state.update(:appgroup, appgroup_name, :down)
+        b_result = true
+      else
+        outputs 'DOWN', "Error taking down appgroup \'#{appgroup_name}\' for zone #{zone_name}.",
+                :err
+        b_result = false
+      end
+
+      b_result
+    end
+
+    # detaches networks to containers of appgroup
+    # 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_fig = Wire::Resource::ResourceFactory
+        .instance.create(:figadapter, "#{appgroup_name}", fig_path)
+
+        container_ids = resource_fig.up_ids || []
+        $log.debug "Got #{container_ids.size} container id(s) from adapter"
+      end
+
+      #
+      resource_nw = Wire::Resource::ResourceFactory
+      .instance.create(:networkinjection, appgroup_name, networks.keys, container_ids)
+      if resource_nw.down?
+        outputs 'DOWN', "appgroup \'#{appgroup_name}\' network " \
+                'attachments already detached.', :ok2
+        state.update(:appgroup, appgroup_name, :down)
+        return true
+      else
+        resource_nw.down
+        if resource_nw.down?
+          outputs 'DOWN', "appgroup \'#{appgroup_name}\' detached " \
+                  "networks #{networks.keys.join(',')}.", :ok
+          state.update(:appgroup, appgroup_name, :down)
+          return true
+        else
+          outputs 'DOWN', "Error detaching networks to appgroup \'#{appgroup_name}\'.",
+                  :err
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/wire/commands/init_command.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # Init Command opens an interactive console dialog
+  # for initializing a model structure
+  # params:
+  # - :target_dir
+  class InitCommand < BaseCommand
+    def run(params = {})
+      puts "Initializing model in #{params[:target_dir]}"
+
+      model_data = {}
+      zone_data = {}
+      network_data = {}
+      model_data.store :zones, zone_data
+      model_data.store :networks, network_data
+
+      zone_names = InitInteractive.ask_for_zone_names
+      if zone_names.size == 0
+        $stderr.puts 'ERROR: must at least have one zone'
+        exit Wire.cli_exitcode(:init_bad_input)
+      end
+      zone_names.each do |zone_name|
+
+        zone_detail = {
+          :desc => 'Enter a short description here',
+          :long_desc => 'Enter a longer description here'
+        }
+
+        zone_data.store zone_name, zone_detail
+
+        networks = InitInteractive.ask_for_network_in_zone zone_name
+        networks.each do |network_name|
+
+          network_details = InitInteractive.ask_detail_data_for_network network_name
+          network_details.merge!({ :zone => zone_name })
+          network_data.store network_name, network_details
+        end
+      end
+
+      # write resulting model to file
+      export_model_file(model_data, params[:target_dir])
+    end
+
+    # Given a model structure and a target dir, this method
+    # ensures that targetdir exists and structure contents
+    # are written to individual files
+    def export_model_file(model_data, target_dir)
+      puts "Target dir is #{target_dir}"
+
+      # ensure target_dir exists
+      if File.exist?(target_dir)
+        if File.directory?(target_dir)
+          $stdout.puts "Writing output to #{target_dir}"
+        else
+          $stderr.puts "ERROR: Target dir #{target_dir} exists, " \
+                       'but is not a directory.'
+          exit Wire.cli_exitcode(:init_dir_error)
+        end
+      else
+        begin
+          FileUtils.mkdir_p(target_dir)
+        rescue => excpt
+          $stderr.puts "ERROR: Unable to create #{target_dir}: #{excpt}"
+          exit Wire.cli_exitcode(:init_dir_error)
+        end
+      end
+
+      [:zones, :networks].each do |element_sym|
+        element = model_data[element_sym]
+        export_element_file element_sym, element, target_dir
+      end
+    end
+
+    # exports an element part of the model to a single file
+    # in target_dir, as yaml.
+    def export_element_file(element_sym, element_data, target_dir)
+      filename = File.join(target_dir, "#{element_sym}.yaml")
+      open(filename, 'w') do |out_file|
+        out_file.puts(element_data.to_yaml)
+      end
+    end
+  end
+end