dewiring 0.1.2

data/lib/wire/commands/init_interactive.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # interactive ask_ commands
+  class InitInteractive
+    # ask for a comma separated list of zone names
+    # returns
+    # - [Array] of zone names
+    def self.ask_for_zone_names
+      question = <<-EOF
+Please enter the names of desired system zones,
+as a comma-separated list:
+      EOF
+      puts question
+      print '> '
+
+      line = STDIN.gets.chomp
+
+      line.split(',').map { |zone_name| zone_name.strip }
+    end
+
+    # Ask for network names in a zone given by +zone_name+
+    # Returns
+    # - [Array] of network names
+    def self.ask_for_network_in_zone(zone_name)
+      question = <<-EOF
+  - Configuring networks in zone #{zone_name}:
+  Please enter the names of logical networks
+  (or leave empty if no networks desired):
+      EOF
+      puts question
+      print '> '
+
+      line = STDIN.gets.chomp
+
+      line.split(',').map { |network_name| network_name.strip }
+    end
+
+    # For a network given by +network_name+, ask for details
+    # i.e. ipaddress etc.
+    # Returns
+    # - [Hash] of details
+    def self.ask_detail_data_for_network(network_name)
+      question = <<-EOF
+    = Configuring network #{network_name}
+    Please enter network address in cidr (i.e.192.168.1.0/24)
+      EOF
+      puts question
+      print '> '
+
+      line = STDIN.gets.chomp
+      result = {}
+
+      result.store :network, line.chomp.strip
+
+      question = <<-EOF
+    Please enter ip address of this network on host (i.e.192.168.1.1)
+    OR leave empty if not desired.
+      EOF
+      puts question
+      print '> '
+
+      line = STDIN.gets.chomp.strip
+
+      result.store(:hostip, line) if line.size > 0
+
+      result
+    end
+  end
+end

data/lib/wire/commands/spec_command.rb

@@ -0,0 +1,240 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # SpecCommand generates a serverspec output for
+  # given model which tests all model elements.
+  # optionally runs serverspec
+  class SpecCommand < BaseCommand
+    # +project+ to operate on
+    attr_accessor :project
+    # +target_dir+ to read model from (and put specs into)
+    attr_accessor :target_dir
+
+    # spec_code will contain all serverspec
+    # code blocks, ready to be written to file
+    attr_accessor :spec_code
+
+    # initializes empty spec
+    def initialize
+      @spec_code = []
+    end
+
+    # process specification for whole project model
+    def run_on_project
+      @target_dir = @params[:target_dir]
+      zones = @project.get_element('zones')
+
+      # iterates all zones, descend into zone
+      run_on_project_zones(zones)
+
+      # use the specwrite class to write a complete
+      # serverspec example in a subdirectory(serverspec)
+      target_specdir = File.join(@target_dir, 'serverspec')
+
+      begin
+        spec_writer = SpecWriter.new(target_specdir, @spec_code)
+        spec_writer.write
+
+        outputs 'SPEC', "Serverspecs written to #{target_specdir}. Run:"
+        outputs 'SPEC', "( cd #{target_specdir}; sudo rake spec )"
+        outputs 'SPEC', 'To run automatically, use --run'
+      rescue => exception
+        $log.error "Error writing serverspec files, #{exception}"
+        STDERR.puts e.inspect
+      end
+
+      run_serverspec(target_specdir) if @params[:auto_run]
+    end
+
+    # executes serverspec in its target directory
+    # TODO: stream into stdout instead of Kernel.``
+    # params:
+    # +target_dir+ model and output dir
+    def run_serverspec(target_specdir)
+      $log.debug 'Running serverspec'
+      cmd = "cd #{target_specdir} && sudo rake spec"
+      $log.debug "cmd=#{cmd}"
+      result = `#{cmd}`
+      puts result
+    end
+
+    # run verification on +zones+
+    def run_on_project_zones(zones)
+      zones.select do |zone_name, _|
+        $log.debug("Creating specs for zone #{zone_name} ...")
+        run_on_zone(zone_name)
+        $log.debug("Done for zone #{zone_name} ...")
+      end
+    end
+
+    # run spec steps in given +zone_name+
+    def run_on_zone(zone_name)
+      networks = @project.get_element('networks')
+
+      # select networks in current zone only
+      networks_in_zone = networks.select do|_, network_data|
+        network_data[:zone] == zone_name
+      end
+      networks_in_zone.each do |network_name, network_data|
+        run_on_network_in_zone zone_name, network_name, network_data
+      end
+
+      # select application groups in current zone
+      objects_in_zone('appgroups', zone_name).each do |appgroup_name, appgroup_data|
+        run_on_appgroup_in_zone zone_name, appgroup_name, appgroup_data
+      end
+    end
+
+    # given a network object, this generates spec
+    # for it.
+    # params:
+    # +zone_name+  name of zone (needed for erb context)
+    # +bridge_name+  name of network/bridge (needed for erb context)
+    # +network_data+  network details
+    # rubocop:disable Lint/UnusedMethodArgument
+    # rubocop:disable Lint/UselessAssignment
+    # :reek:UnusedParameters
+    def run_on_network_in_zone(zone_name, bridge_name, network_data)
+      $log.debug("Creating specs for network #{bridge_name}")
+
+      template = SpecTemplates.build_template__bridge_exists
+      erb = ERB.new(template, nil, '%')
+      @spec_code << erb.result(binding)
+
+      # render template for hostip (if any)
+      ip = network_data[:hostip]
+      if ip
+        template = SpecTemplates.build_template__ip_is_up
+        erb = ERB.new(template, nil, '%')
+        @spec_code << erb.result(binding)
+      end
+
+      # render dhcp spec (if any)
+      dhcp_data = network_data[:dhcp]
+      if dhcp_data
+        ip_start = dhcp_data[:start]
+        ip_end = dhcp_data[:end]
+        hostip = ip
+        template = SpecTemplates.build_template__dhcp_is_valid
+        erb = ERB.new(template, nil, '%')
+        @spec_code << erb.result(binding)
+
+      end
+
+      $log.debug("Done for network #{bridge_name}")
+    end
+
+    # given an appgroup object, this generates spec
+    # for it.
+    # params:
+    # +zone_name+  name of zone (needed for erb context)
+    # +appgroup_name+  name of appgroup (needed for erb context)
+    # +appgroup_data+  appgroup details
+    # rubocop:disable Lint/UnusedMethodArgument   Lint/UselessAssignment
+    # :reek:UnusedParameters
+    def run_on_appgroup_in_zone(zone_name, appgroup_name, appgroup_data)
+      $log.debug("Creating specs for appgroup #{appgroup_name}")
+
+      # check controller
+      controller_data = appgroup_data[:controller]
+      if controller_data[:type] == 'fig'
+        # get fig file name
+        figfile_part = controller_data[:file] || "#{zone_name}/fig.yaml"
+        figfile = File.join(File.expand_path(@target_dir), figfile_part)
+
+        template = SpecTemplates.build_template__fig_file_is_valid
+        erb = ERB.new(template, nil, '%')
+        @spec_code << erb.result(binding)
+
+        template = SpecTemplates.build_template__fig_containers_are_up
+        erb = ERB.new(template, nil, '%')
+        @spec_code << erb.result(binding)
+      end
+
+      $log.debug("Done for appgroup #{appgroup_name}")
+    end
+  end
+
+  # SpecWriter is able to create a directory
+  # structure according to basic serverspec
+  # needs and fill in the templates
+  class SpecWriter
+    # create SpecWriter in +target_dir+ directory
+    # with given +spec_contents+
+    def initialize(target_dir, spec_contents)
+      @target_dir = target_dir
+      @spec_contents = spec_contents
+    end
+
+    # writes spec to disk
+    def write
+      ensure_directory_structure
+      ensure_files
+    end
+
+    # make sure that we have a rspec-conformant dir structure
+    def ensure_directory_structure
+      ensure_directory @target_dir
+      ensure_directory File.join(@target_dir, 'spec')
+      ensure_directory File.join(@target_dir, 'spec', 'localhost')
+    end
+
+    # writes erb +template+ to open +file+ object
+    def write_template(template, file)
+      erb = ERB.new(template, nil, '%')
+      file.puts(erb.result(binding))
+    end
+
+    # ensures that all serverspec skeleton files such as
+    # Rakefile, spec_helper etc. exist
+    # Then writes the models specification files into the
+    # skeleton
+    def ensure_files
+      rakefile_name = File.join(@target_dir, 'Rakefile')
+      file?(rakefile_name) || File.open(rakefile_name, 'w') do |file|
+        write_template(SpecTemplates.template_rakefile, file)
+      end
+
+      spechelper_name = File.join(@target_dir, 'spec', 'spec_helper.rb')
+      file?(spechelper_name) || File.open(spechelper_name, 'w') do |file|
+        write_template(SpecTemplates.template_spec_helper, file)
+      end
+
+      specfile_name = File.join(@target_dir, 'spec', 'localhost', 'wire_spec.rb')
+      File.open(specfile_name, 'w') do |file|
+        template = <<ERB
+require 'spec_helper.rb'
+
+# begin of generated specs
+
+<%= @spec_contents.join('\n') %>
+
+# end of spec file
+ERB
+        write_template(template, file)
+      end
+    end
+
+    private
+
+    # make sure that +target_dir+ exists
+    def ensure_directory(target_dir)
+      return if File.exist?(target_dir)
+      begin
+        FileUtils.mkdir_p(target_dir)
+      rescue => excpt
+        $log.error "ERROR: Unable to create #{target_dir}: #{excpt}"
+      end
+    end
+
+    # checks if +target_file+ exists
+    def file?(target_file)
+      File.exist?(target_file) && File.file?(target_file)
+    end
+  end
+end

data/lib/wire/commands/spec_templates.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
+  # stateless erb template methods used by spec_command.rb
+  class SpecTemplates
+    # rubocop:disable Lint/UnusedMethodArgument
+    # :reek:UnusedParameters
+    def self.build_template__bridge_exists
+      <<ERB
+  describe 'In zone <%= zone_name %> we should have an ovs bridge named <%= bridge_name %>' do
+    describe command "sudo ovs-vsctl list-br" do
+      its(:stdout) { should match /<%= bridge_name %>/ }
+    end
+  end
+ERB
+    end
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    # :reek:UnusedParameters
+    def self.build_template__ip_is_up
+      <<ERB
+  describe 'In zone <%= zone_name %> we should have the ip <%= ip %> ' \
+           'on ovs bridge named <%= bridge_name %>' do
+    describe interface "<%= bridge_name %>" do
+      it { should have_ipv4_address '<%= ip %>' }
+    end
+  end
+ERB
+    end
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    # :reek:UnusedParameters
+    # requires zone_name, hostip, bridge_name, ip_start, ip_end
+    def self.build_template__dhcp_is_valid
+      <<ERB
+  describe 'In zone <%= zone_name %> we should have dhcp service on ip <%= hostip %> ' \
+           'on ovs bridge named <%= bridge_name %>, serving addresses from ' \
+           '<%= ip_start %> to <%= ip_end %>' do
+
+    describe file '/etc/dnsmasq.d/wire__<%= zone_name %>.conf' do
+      it { should be_file }
+      its(:content) { should match /<%= ip_start %>/ }
+      its(:content) { should match /<%= ip_end %>/ }
+      its(:content) { should match /<%= bridge_name %>/ }
+    end
+
+    describe process 'dnsmasq' do
+      it { should be_running }
+    end
+
+    describe port(67) do
+      it { should be_listening.with('udp') }
+    end
+
+    describe command '/bin/netstat -nlup' do
+      its(:stdout) { should match /67.*dnsmasq/ }
+    end
+  end
+ERB
+    end
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    # :reek:UnusedParameters
+    # requires figfile, appgroup_name
+    def self.build_template__fig_file_is_valid
+      <<ERB
+  describe 'In zone <%= zone_name %> we should have fig model file for '\
+           'appgroup <%= appgroup_name %>' do
+    describe file '<%= figfile %>' do
+      it { should be_file }
+    end
+  end
+ERB
+    end
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    # :reek:UnusedParameters
+    # requires zone_name, figfile, appgroup_name
+    def self.build_template__fig_containers_are_up
+      <<ERB
+  describe 'In zone <%= zone_name %> we should have containers managed '\
+           'by fig for appgroup <%= appgroup_name %>' do
+    describe command 'sudo fig -p <%= appgroup_name %> -f <%= figfile %> ps' do
+      its(:stdout) { should match /Up/ }
+    end
+  end
+ERB
+    end
+
+    # generate template part
+    # returns
+    # - erb template for spec_helper.rb file
+    def self.template_spec_helper
+      <<ERB
+require 'serverspec'
+require 'rspec/its'
+
+include SpecInfra::Helper::Exec
+include SpecInfra::Helper::DetectOS
+
+RSpec.configure do |c|
+  if ENV['ASK_SUDO_PASSWORD']
+    require 'highline/import'
+    c.sudo_password = ask("Enter sudo password: ") { |q| q.echo = false }
+  else
+    c.sudo_password = ENV['SUDO_PASSWORD']
+  end
+end
+ERB
+    end
+
+    # generate template part
+    # returns
+    # - erb template for Rakefile
+    def self.template_rakefile
+      <<ERB
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/*/*_spec.rb'
+  t.rspec_opts = '--format documentation --color'
+end
+
+task :default => :spec
+ERB
+    end
+  end
+end

data/lib/wire/commands/up_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
+  # UpCommand reads yaml, parses model elements
+  # and brings all defined model elements "up", that is
+  # starting bridges, containers etc.
+  class UpCommand < UpDownCommand
+    # allow to get access to handler object
+    attr_reader :handler
+
+    # initialize
+    def initialize
+      @handler = UpCommandHandler.new
+    end
+
+    # run in given +zone_name+:
+    # returns:
+    # - bool: true if successful, false otherwise
+    # rubocop:disable CyclomaticComplexity
+    def run_on_zone(zone_name)
+      b_result = true
+
+      networks = @project.get_element('networks')
+
+      # 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 up network #{network_name}")
+
+        success = @handler.handle_bridge(network_name)
+        b_result &= success
+        if success
+          # if we have a host ip on that bridge, take it down first
+          b_result &= default_handle_hostip(network_name, network_data, @handler)
+
+          # if we have dhcp, configure dnsmasq
+          b_result &= default_handle_dhcp(zone_name, network_name, network_data, @handler)
+        else
+          $log.debug("Will not touch dependant objects of #{network_name} due to previous error(s)")
+        end
+      end
+
+      # select appgroups in this zone and bring them up
+      appgroups_in_zone = objects_in_zone('appgroups', zone_name)
+      appgroups_in_zone.each do |appgroup_name, appgroup_data|
+        $log.debug("Processing appgroup \'#{appgroup_name}\'")
+
+        success = handler.handle_appgroup(zone_name,
+                                          appgroup_name, appgroup_data,
+                                          @project.target_dir)
+        b_result &= success
+
+        # 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
+      end
+
+      b_result
+    end
+  end
+end

data/lib/wire/commands/up_command_handler.rb

@@ -0,0 +1,193 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # handle_xxx methods for UpCommand
+  # rubocop:disable ClassLength
+  class UpCommandHandler < BaseCommand
+    # bring bridge resource up, identified by
+    # +bridge_name+
+    # Returns
+    # - [Bool] true if hostip if up on bridge
+    def handle_bridge(bridge_name)
+      b_result = true
+
+      # we should have a bridge with that name.
+      bridge_resource = Wire::Resource::ResourceFactory.instance.create(:ovsbridge, bridge_name)
+      if bridge_resource.up?
+        outputs 'UP',  "Bridge #{bridge_name} already up.", :ok2
+      else
+        bridge_resource.up
+        if bridge_resource.up?
+          outputs 'UP',  "Bridge #{bridge_name} up.", :ok
+          state.update(:bridge, bridge_name, :up)
+        else
+          outputs 'UP',  "Error bringing up bridge #{bridge_name}.", :err
+          b_result = false
+        end
+
+      end
+      b_result
+    end
+
+    # bring ip resource up on device identified by
+    # +bridge_name+ and +host_ip+
+    # Returns
+    # - [Bool] true if hostip if up on bridge
+    def handle_hostip(bridge_name, hostip)
+      b_result = true
+
+      # we should have a bridge with that name.
+      hostip_resource = Wire::Resource::ResourceFactory
+        .instance.create(:bridgeip, hostip, bridge_name)
+      if hostip_resource.up?
+        outputs 'UP',  "IP #{hostip} on bridge #{bridge_name} already up.", :ok2
+      else
+        hostip_resource.up
+        if hostip_resource.up?
+          outputs 'UP',  "IP #{hostip} on bridge #{bridge_name} up.", :ok
+          state.update(:hostip, hostip, :up)
+        else
+          outputs 'UP',  "Error bringing up ip #{hostip} on bridge #{bridge_name}.", :err
+          b_result = false
+        end
+
+      end
+      b_result
+    end
+
+    # configures dnsmasq for dhcp
+    # +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.up?
+        outputs 'UP', "dnsmasq/dhcp config on network \'#{network_name}\' is already up.", :ok2
+        return true
+      else
+        resource_dhcp.up
+        if resource_dhcp.up?
+          outputs 'UP', "dnsmasq/dhcp config on network \'#{network_name}\' is up.", :ok
+          state.update(:dnsmasq, network_name, :up)
+          return true
+        else
+          outputs 'UP', "Error configuring dnsmasq/dhcp config on network \'#{network_name}\'.",
+                  :err
+          return false
+        end
+      end
+    end
+
+    # take the appgroups' controller and directs methods to
+    # it. First checks if appgroup is up. If so, ok. If not, bring it up
+    # and ensure that it's up
+    # Params:
+    # +zone_name+:: Name of zone
+    # +appgroup_name+:: Name of Appgroup
+    # +appgroup_entry+:: Appgroup data from model
+    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, 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.up?
+        outputs 'UP', "appgroup \'#{appgroup_name}\' in zone #{zone_name} is already up.", :ok2
+        return true
+      else
+        resource_fig.up
+        if resource_fig.up?
+          outputs 'UP', "appgroup \'#{appgroup_name}\' in zone #{zone_name} is up.", :ok
+          state.update(:appgroup, appgroup_name, :up)
+          return true
+        else
+          outputs 'UP', "Error bringing up appgroup \'#{appgroup_name}\' in zone #{zone_name} .",
+                  :err
+          return false
+        end
+      end
+    end
+
+    # attaches 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.up?
+        outputs 'UP', "appgroup \'#{appgroup_name}\' already has valid network " \
+                'attachments.', :ok2
+        state.update(:appgroup, appgroup_name, :up)
+        return true
+      else
+        resource_nw.up
+        if resource_nw.up?
+          outputs 'UP', "appgroup \'#{appgroup_name}\' attached " \
+                  "networks #{networks.keys.join(',')}.", :ok
+          state.update(:appgroup, appgroup_name, :up)
+          return true
+        else
+          outputs 'UP', "Error attaching networks to appgroup \'#{appgroup_name}\'.",
+                  :err
+          return false
+        end
+      end
+    end
+  end
+end