dewiring 0.1.2

data/lib/wire/resource/dhcp_range_config.rb

@@ -0,0 +1,135 @@
+# 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
+    # DHCPRangeConfiguration is a configuration resource
+    # for dnsmasq to support dhcp for a given network range
+    # on a given interface
+    class DHCPRangeConfiguration < ResourceBase
+      # +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)
+      # +executables+ [Hash] of binaries needed to control
+      # the resource
+      attr_accessor	:address_start, :address_end, :network_name, :network, :executables
+
+      # initialize the resourcen object with
+      # given +name+ and attributes
+      # params:
+      # +name+	resource name
+      # +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)
+      def initialize(name, network_name, network, address_start, address_end)
+        super(name)
+
+        self.network_name = network_name
+        self.network = network
+        self.address_start = address_start
+        self.address_end = address_end
+
+        # TODO: make configurable
+        @executables = {
+          :service => '/usr/sbin/service'
+        }
+      end
+
+      # Build file name of dnsmasq file
+      # TODO: make configurable
+      def create_dnsmaqs_config_filename
+        "/etc/dnsmasq.d/#{@name}__#{@network_name}.conf"
+      end
+
+      # check if configuration entry exists
+      def exist?
+        filename = create_dnsmaqs_config_filename
+        File.exist?(filename) && File.readable?(filename) && File.file?(filename)
+      end
+
+      # check if dnsmasq is listening on the network device
+      def up?
+        return false unless exist?
+
+        filename = create_dnsmaqs_config_filename
+
+        cmd = "/bin/grep #{network_name} #{filename} >/dev/null 2>&1"
+        $log.debug("executing cmd=#{cmd}")
+        `#{cmd}`
+
+        ($CHILD_STATUS == 0)
+      end
+
+      # restart dnsmasq service
+      def restart_dnsmasq
+        $log.debug('Restarting dnsmasq')
+        LocalExecution.with(@executables[:service],
+                            %w(dnsmasq restart),
+                            { :b_sudo => true, :b_shell => false }) do |up_exec_obj|
+          up_exec_obj.run
+          return (up_exec_obj.exitstatus == 0)
+        end
+      end
+
+      # creates the configuration and restarts dnsmasq
+      def up
+        filename = create_dnsmaqs_config_filename
+
+        # use sudo'ed touch/chmod to create us the file we need
+        LocalExecution.with("sudo touch #{filename} && " \
+                            "sudo chmod u+rw #{filename} && " \
+                            "sudo chown #{ENV['USER']} #{filename}",
+                            [], { :b_sudo => false, :b_shell => true }) do |up_exec_obj|
+          up_exec_obj.run
+        end
+        $log.debug("(Over-)writing #{filename}")
+        File.open(filename, 'w') do |file|
+          # TODO: add netmask
+          file.puts "dhcp-range=#{@network_name},#{@address_start},#{@address_end}"
+        end
+
+        restart_dnsmasq
+      rescue => exception
+        $log.error("Error writign dnsmasq config file/restarting dnsmasq, #{exception}")
+        return false
+      end
+
+      # checks if dnsmasq is NOT servicing dhcp request on network device
+      def down?
+        !(up?)
+      end
+
+      # removes configuration entry and restarts dnsmasq
+      def down
+        filename = create_dnsmaqs_config_filename
+        if File.exist?(filename) && File.readable?(filename) && File.file?(filename)
+          $log.debug("Deleting #{filename}")
+          LocalExecution.with("sudo rm #{filename}",
+                              [], { :b_sudo => false, :b_shell => true }) do |up_exec_obj|
+            up_exec_obj.run
+          end
+
+          restart_dnsmasq
+        end
+      rescue => exception
+        $log.error("Error deleting dnsmasq config file/restarting dnsmasq, #{exception}")
+        return false
+      end
+
+      # Returns a string representation
+      def to_s
+        "DHCPRangeConfiguration:[#{name},network_name=#{network[:name]}" \
+        ",start=#{address_start},end=#{address_end}]"
+      end
+    end
+  end
+end

data/lib/wire/resource/fig_adapter.rb

@@ -0,0 +1,127 @@
+# 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
+    # Fig Adapter resource, runs fig script
+    # to control containers
+    class FigAdapter < ResourceBase
+      # +executables+ [Hash] of binaries needed to control
+      # the resource
+      attr_accessor :figfile, :executables
+
+      # initialize the object with
+      # given +name+ and path to fig file
+      # params:
+      # - name	fig filename name, i.e. "backend.yaml"
+      def initialize(name, figfile)
+        super(name.tr('_-', ''))
+        @figfile = figfile
+
+        # TODO: make configurable
+        @executables = {
+          :fig => '/usr/local/bin/fig'
+        }
+      end
+
+      # checks if containers exist
+      def exist?
+        up?
+      end
+
+      # calls fig with correct -p and -f options
+      # and given +command_arr+ array
+      def with_fig(command_arr)
+        LocalExecution.with(@executables[:fig],
+                            ['-p', @name, '-f', @figfile, command_arr].flatten) do |exec_obj|
+          yield exec_obj
+        end
+      end
+
+      # checks if containers are up (using fig ps)
+      def up?
+        with_fig(%w(ps)) do |exec_obj|
+          exec_obj.run
+
+          # parse stdout..
+          re = Regexp.new "^#{@name}.*Up.*"
+          num_up = 0
+          exec_obj.stdout.split("\n").each do |line|
+            next unless line.match(re)
+
+            $log.debug "Matching fig ps output: #{line}"
+
+            num_up += 1
+          end
+          $log.debug 'No containers found in fig ps output' if num_up == 0
+
+          return (exec_obj.exitstatus == 0 && num_up > 0)
+        end
+      end
+
+      # returns the container ids of currently running containers
+      # as [Array] of ids
+      def up_ids
+        with_fig(%w(ps -q)) do |exec_obj|
+          exec_obj.run
+
+          # parse stdout..
+          re = Regexp.new '^[0-9a-zA-Z]+'
+          res = []
+
+          exec_obj.stdout.split("\n").each do |line|
+            next unless line.match(re)
+            res << line.chomp.strip
+          end
+
+          return res
+        end
+        nil
+      end
+
+      # brings containers up
+      def up
+        $log.debug 'Bringing up fig containers ...'
+        with_fig(%w(up -d --no-recreate)) do |exec_obj|
+          exec_obj.run
+
+          return (exec_obj.exitstatus == 0)
+        end
+      end
+
+      # checks if the bridge is down
+      def down?
+        !(up?)
+      end
+
+      # takes containers down
+      def down
+        $log.debug 'Taking down fig containers ...'
+        with_fig(['stop']) do |exec_obj|
+          exec_obj.run
+
+          return false if (exec_obj.exitstatus != 0)
+        end
+        $log.debug 'Removing fig containers ...'
+        with_fig(%w(rm --force)) do |exec_obj|
+          exec_obj.run
+
+          return false if (exec_obj.exitstatus != 0)
+        end
+        true
+      end
+
+      # Returns a string representation
+      def to_s
+        "FigAdapter:[#{name},file=#{figfile}]"
+      end
+    end
+  end
+end

data/lib/wire/resource/ip_binary.rb

@@ -0,0 +1,141 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+# Wire module
+module Wire
+  # Resource module
+  module Resource
+    # IPBinary class wraps /sbin/ip and
+    # is able to parse the output and pass it
+    # on in a resource style
+    class IPBinary < ResourceBase
+      # sets the executables map
+      def initialize
+        super('undefined')
+        @executables = {
+          :ip => '/sbin/ip'
+        }
+      end
+
+      # call ip addr show and returns details
+      # as a map
+      # params:
+      # +device+ device (i.e. bridge0 to operate on)
+      # returns:
+      # - detail data of device as a map
+      def get_ipaddr_data(device)
+        fail(ArgumentError, 'Device name not given') unless device && device.size > 0
+
+        result = {}
+        stdout = call_addr_show(device)
+
+        # parse line-wise. first line is about the device
+        arr_lines = stdout.split("\n")
+
+        if !arr_lines || arr_lines.size == 0
+          fail("No output from #{@executables[:ip]} on dev #{device}")
+        end
+        result.merge!(get_ipaddr_data_device(arr_lines[0]))
+        result.merge!(get_ipaddr_data_link(arr_lines[0]))
+
+        # iterate all inet lines
+        parse_inet_lines(arr_lines, result)
+
+        result
+      end
+
+      # given the array of output lines (+arr_lines+)from ip binary call,
+      # this method parses the lines and adds structured detail
+      # data to +result+ map
+      def parse_inet_lines(arr_lines, result)
+        inet_map = {}
+        arr_lines[1..-1].select { |line| line =~ /inet / }.each do |line|
+          inet_result = get_ipaddr_data_inet(line)
+          inet_map.store inet_result[:device], inet_result
+        end
+        result.store(:inet, inet_map)
+      end
+
+      # calls /sbin/ip addr show <device>
+      # for given device name
+      def call_addr_show(device)
+        LocalExecution.with(@executables[:ip],
+                            ['addr', 'show', device]) do |up_exec_obj|
+          up_exec_obj.run
+          fail "Error on execution of #{@executables[:ip]}, " \
+            "exitcode=#{up_exec_obj.exitstatus}" unless up_exec_obj.exitstatus == 0
+          return up_exec_obj.stdout
+        end
+      end
+
+      # runs a set of +matchers+ against given +line+ string,
+      # returns results
+      # params:
+      # +line+: line from command output
+      # +matchers+: map of regexps
+      # returns:
+      # - [HashMap] with keys identical to +matchers+ map
+      def generic_match_data(line, matchers)
+        result = {}
+
+        matchers.each do |key, regexp|
+          md = line.match regexp
+          result.store(key, md[1]) if md && md.size > 1
+        end
+
+        result
+      end
+
+      # retrieve device data from input
+      # params:
+      # +line+: input line from /sbin/ip addr show w/ device data
+      # returns:
+      # [HashMap] with id, devicename, options, mtu, state and group details
+      def get_ipaddr_data_device(line)
+        device_matchers = {
+          :id      => /^([0-9]+):/,
+          :device  => /^[0-9]+: (\w+): /,
+          :options => /^[0-9]+: \w+: <([\w,_]+)> /,
+          :mtu     => /mtu (\w+)/,
+          :state   => /state (\w+)/,
+          :group   => /group (\w+)/
+        }
+        generic_match_data(line, device_matchers)
+      end
+
+      # retrieve link state data from input
+      # params:
+      # +line+: input line from /sbin/ip addr show w/ link data
+      # returns:
+      # [HashMap] with type, mac address and (optional) broadcast
+      def get_ipaddr_data_link(line)
+        link_matchers = {
+          :type    => /link\/(\w+) /,
+          :mac     => /link\/\w+ ([0-9:]+)/,
+          :brd     => /brd ([0-9:]+)/
+        }
+        generic_match_data(line, link_matchers)
+      end
+
+      # retrieve inet state data from input
+      # params:
+      # +line+: input line from /sbin/ip addr show w/ "inet" data
+      # returns:
+      # [HashMap] with ip, broadcast, scope, device
+      def get_ipaddr_data_inet(line)
+        inet_matchers = {
+          :ip      => /inet ([0-9\.]+)\//,
+          :cidr    => /inet ([0-9\.\/]+) /,
+          :network => /inet [0-9\.]+(\/[0-9]+) /,
+          :brd     => /brd ([0-9\.]+)/,
+          :scope   => /scope (\w+)/,
+          :device  => / ([\w:]+)$/
+        }
+        generic_match_data(line, inet_matchers)
+      end
+    end
+  end
+end

data/lib/wire/resource/ipaddr_ext.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+# The MIT License (MIT)
+# Copyright (c) 2014 Andreas Schmidt, andreas@de-wiring.net
+#
+
+require 'ipaddr'
+
+# reopen class to add needed methods
+# for IP/subnetwork stuff
+class IPAddr
+  # TODO: check if needed
+  # attr_reader :netmask_address
+
+  # compute broadcast address
+  def broadcast_address
+    _to_string(@addr | (2**32 - 1) - (@mask_addr))
+  end
+
+  # checks if self is within network range
+  # of given +network+ (IPAddr object)
+  # i.e. 10.10.2.0/24 is part of 10.10.0.0/16
+  # params:
+  # +network+ i.e. 10.10.0.0/16, if self == 10.10.2.0/24
+  # returns
+  # [bool]
+  def in_range_of?(network)
+    return false unless network.include?(self)
+    return false unless
+        network.include?(IPAddr.new(broadcast_address))
+    true
+  end
+
+  # return netmask as a string
+  def netmask
+    _to_string(@mask_addr)
+  end
+end

data/lib/wire/resource/ipaddr_on_intf.rb

@@ -0,0 +1,108 @@
+# 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
+    # Generic IP Address on an interface
+    # Able to add and remove ips on interfaces
+    class IPAddressOnIntf < ResourceBase
+      # +device+  (bridge) device name, i.e. "eth1"
+      # +executables+   array of paths to needed binaries
+      attr_accessor	:device, :executables
+
+      # initialize the object with
+      # given name and device
+      # params:
+      # +name+	ip address in cidr notation
+      # +device+ device/interface name
+      def initialize(name, device)
+        super(name)
+
+        fail(ArgumentError, 'ip may not be empty') unless name && name.size > 0
+        fail(ArgumentError, 'device may not be empty') unless device && device.size > 0
+
+        @device = device
+        @executables = {
+          :ip => '/sbin/ip'
+        }
+      end
+
+      # constructs an ip addr show / grep command to see if an
+      # ip address is up on a device
+      # returns
+      # - command as [String]
+      def construct_exist_command
+        "#{@executables[:ip]} addr show #{device} | grep -wq -E \"^\\W*inet #{@name}.*#{@device}\""
+      end
+
+      # runs the "exist" command
+      # returns
+      # - [Boolean]: true: ip is on on device, false otherwise
+      def exist?
+        LocalExecution.with(construct_exist_command, [],
+                            { :b_shell => false, :b_sudo => false }) do |exec_obj|
+          exec_obj.run
+          return (exec_obj.exitstatus == 0)
+        end
+      end
+
+      # same as exist?
+      def up?
+        exist?
+      end
+
+      # constructs an ip addr add command to set up an ip
+      # returns
+      # - command as [String]
+      def construct_add_command
+        "#{@executables[:ip]} addr add #{name} dev #{device}"
+      end
+
+      # takes an ip up on given device
+      # returns
+      # - [Boolean]: true: ok, false otherwise
+      def up
+        LocalExecution.with(construct_add_command, [],
+                            { :b_shell => false, :b_sudo => true }) do |exec_obj|
+          exec_obj.run
+          return (exec_obj.exitstatus == 0)
+        end
+      end
+
+      # constructs an ip addr del command to delete an ip
+      # returns
+      # - command as [String]
+      def construct_delete_command
+        "#{@executables[:ip]} addr del #{name} dev #{device}"
+      end
+
+      # thats the opposite of up
+      def down?
+        !(up?)
+      end
+
+      # takes an ip down on given device
+      # returns
+      # - [Boolean]: true: ok, false otherwise
+      def down
+        LocalExecution.with(construct_delete_command, [],
+                            { :b_shell => false, :b_sudo => true }) do |exec_obj|
+          exec_obj.run
+          return (exec_obj.exitstatus == 0)
+        end
+      end
+
+      # generate a string representation
+      def to_s
+        "IPAddressOnIntf:[#{name},device=#{device}]"
+      end
+    end
+  end
+end

data/lib/wire/resource/network_injection.rb

@@ -0,0 +1,138 @@
+# 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
+    # Network Injection Resource controls the allocation
+    # of host and container network resources for
+    # all containers of an application group
+    class NetworkInjection < ResourceBase
+      # +executables+ [Hash] of binaries needed to control
+      # the resource
+      attr_accessor :executables
+
+      # ids of containers of appgroup
+      attr_accessor :containers
+
+      # names of networks to attach appgroup containers to
+      attr_accessor :networks
+
+      # initialize the object with
+      # given appgroup +name+ and +container+ ids
+      # params:
+      # ++name++: Application group name
+      # ++networks++: [Array] of network names to attach containers to
+      # ++containers+: [Array] of container ids (i.e. from fig ps -q)
+      def initialize(name, networks, containers)
+        super(name)
+        self.containers = containers
+        self.networks = networks
+
+        # TODO: make configurable
+        @executables = {
+          :network => '/usr/local/bin/wire-network-container.sh'
+        }
+      end
+
+      # calls helper executable with correct +action+
+      # and given +command_arr+ array
+      def with_helper(action, params)
+        # puts "#{@executables[:network]} #{action} --debug -- #{params.join(' ')}"
+        LocalExecution.with(@executables[:network],
+                            [action, '--debug', '--', params].flatten,
+                            { :b_sudo => false, :b_shell => false }) do |exec_obj|
+          yield exec_obj
+        end
+      end
+
+      # calls the verify action to see if container
+      # has been networked correctly
+      def exist?
+        up?
+      end
+
+      # for the network helper script, construct
+      # an array of container devices names and bridge names,
+      # i.e. eht1:br0 meaning container will be attached
+      # to bridge br0 with eth1.
+      # first iteration: choose device=network_name=bridge_name,
+      # all the same.
+      def construct_helper_params
+        res = []
+        networks.each do |network|
+          res << "#{network}:#{network}"
+        end
+        res.join(' ')
+      end
+
+      # same as exist?
+      def up?
+        with_helper('verify', [construct_helper_params,
+                               containers.join(' ')]) do |exec_obj|
+          exec_obj.run
+
+          return (exec_obj.exitstatus == 0 && count_errors(exec_obj) == 0)
+        end
+      end
+
+      # attaches containers to networks
+      def up
+        $log.debug 'Attaching containers to networks ...'
+        with_helper('attach', [construct_helper_params,
+                               containers.join(' ')]) do |exec_obj|
+          exec_obj.run
+
+          return (exec_obj.exitstatus == 0 && count_errors(exec_obj) == 0)
+        end
+      end
+
+      # checks if the bridge is down
+      def down?
+        !(up?)
+      end
+
+      # detaches network interfaces form containers and bridges
+      def down
+        $log.debug 'Taking down container network attachments ...'
+        with_helper('detach', [construct_helper_params,
+                               containers.join(' ')]) do |exec_obj|
+          exec_obj.run
+
+          return (exec_obj.exitstatus == 0 && count_errors(exec_obj) == 0)
+        end
+      end
+
+      # Returns a string representation
+      def to_s
+        "NetworkInjection:[#{name},containers=#{containers.join('/')}," \
+        "network_args=#{construct_helper_params}]"
+      end
+
+      private
+
+      # counts errors in a text output from given
+      # +exec_obj+
+      def count_errors(exec_obj)
+        num_errors = 0
+        re = Regexp.new '^ERROR.*'
+        exec_obj.stdout.split("\n").each do |line|
+          $log.debug line
+
+          next unless line.match(re)
+
+          $log.debug "Matching error output: #{line}"
+
+          num_errors += 1
+        end
+        num_errors
+      end
+    end
+  end
+end