construqt 0.0.1

data/lib/construqt/services.rb

@@ -0,0 +1,53 @@
+module Construqt
+  class Services
+
+    class DhcpV4Relay
+      attr_accessor :servers, :name
+      def initialize(name)
+        self.name = name
+        self.servers = []
+      end
+      def add_server(ip)
+        ip = IPAddress.parse(ip)
+        throw "ip must be a v4 address" unless ip.ipv4?
+        self.servers << ip
+        self
+      end
+    end
+    class DhcpV6Relay
+      attr_accessor :servers, :name
+      def initialize(name)
+        self.name = name
+        self.servers = []
+      end
+      def add_server(ip)
+        ip = IPAddress.parse(ip)
+        throw "ip must be a v6 address" unless ip.ipv6?
+        self.servers << ip
+        self
+      end
+    end
+    class Radvd
+      attr_accessor :servers, :name
+      def initialize(name)
+        self.name = name
+      end
+    end
+
+    def initialize
+      @services = {}
+    end
+
+    def find(name)
+      found = @services[name]
+      throw "service with name #{name} not found" unless found
+      found
+    end
+
+    def add(service)
+      @services[service.name] = service
+      self
+    end
+
+  end
+end

data/lib/construqt/tags.rb

@@ -0,0 +1,61 @@
+
+module Construqt
+  module Tags
+    @tags = {}
+    @object_id_tags = {}
+    def self.add(tag_str, &block)
+      (name, *tags) = tag_str.split(/\s*#\s*/)
+      obj = block.call(name, tags)
+      #binding.pry
+      tags && tags.uniq.each do |tag|
+        @tags[tag] ||= []
+        @tags[tag] << obj unless @tags[tag].include?(obj)
+      end
+      if obj.respond_to? :tags
+        obj.tags = tags
+      end
+      @object_id_tags[obj.object_id] ||= []
+      @object_id_tags[obj.object_id] = (@object_id_tags[obj.object_id] + tags).uniq
+      [name, obj]
+    end
+
+    def self.from(obj)
+      @object_id_tags[obj.object_id]
+    end
+
+    def self.find(tag, clazz = nil)
+      #binding.pry
+      ret = (@tags[tag] || []).select{|o| clazz.nil? || o.kind_of?(clazz) }
+      Construqt.logger.warn("tag #{tag} #{clazz.inspect} empty result") if ret.empty?
+      ret
+    end
+
+    def self.ips_net(tag, family)
+      ip_module = family==Construqt::Addresses::IPV4 ? IPAddress::IPv4: IPAddress::IPv6
+      IPAddress::IPv4::summarize(*(@tags[tag]||[]).map do |obj|
+        if obj.kind_of?(IPAddress)
+          obj
+        elsif obj.respond_to? :ips
+          obj.ips
+        elsif obj.kind_of?(Construqt::Flavour::HostDelegate)
+          #binding.pry
+          res = obj.interfaces.values.map do |i|
+            i.delegate.address.ips.map do |a|
+              prefix = a.ipv4? ? 32 : 128
+              ret = IPAddress.parse("#{a.to_s}/#{prefix}")
+              puts "ADR=#{tag} #{ret.to_string} #{a.to_s}"
+              ret
+            end
+          end.flatten
+          puts "HOST=>#{tag} #{res.map{|i| i.to_string }}"
+          res
+        else
+          nil
+        end
+      end.flatten.compact.select do |i|
+        (family==Construqt::Addresses::IPV4 && i.ipv4?) ||
+          (family==Construqt::Addresses::IPV6 && i.ipv6?)
+      end)
+    end
+  end
+end

data/lib/construqt/templates.rb

@@ -0,0 +1,37 @@
+
+module Construqt
+  class Templates
+    def initialize(region)
+      @region = region
+      @templates = {}
+    end
+
+    class Template < OpenStruct
+      def initialize(cfg)
+        super(cfg)
+      end
+
+      def is_tagged?(vlan_id)
+        self.vlans.each do |vlan|
+          return vlan.tagged? if vlan.vlan_id == vlan_id
+        end
+
+        throw "vlan with id #{vlan_id} not found in template #{self}"
+      end
+    end
+
+    def find(name)
+      ret = @templates[name]
+      throw "template with name #{name} not found" unless @templates[name]
+      ret
+    end
+
+    def add(name, cfg)
+      throw "template with name #{name} exists" if @templates[name]
+      cfg['name'] = name
+      ret = Template.new(cfg)
+      @templates[name] = ret
+      ret
+    end
+  end
+end

data/lib/construqt/tests/test_addresses.rb

@@ -0,0 +1,50 @@
+
+addresses = Construqt::Addresses.new(7)
+
+assert_eq(addresses.network, 7)
+
+adr = addresses.create
+
+assert_eq(addresses.all.length, 0)
+
+adr.set_name("jojo")
+assert_eq(adr.name, "jojo")
+
+adr.name = "jojojo"
+assert_eq(adr.name, "jojojo")
+
+adr.add_ip("192.168.0.1")
+assert_eq(adr.all.length, 1)
+assert_eq(adr.v4s.length, 1)
+assert_eq(adr.v6s.length, 0)
+
+adr.add_ip("192.168.0.2")
+assert_eq(adr.all.length, 2)
+assert_eq(adr.v4s.length, 2)
+assert_eq(adr.v6s.length, 0)
+
+adr.add_ip("2000::/27")
+assert_eq(adr.all.length, 3)
+assert_eq(adr.v4s.length, 2)
+assert_eq(adr.v6s.length, 1)
+
+adr.add_ip("2001::/27")
+assert_eq(adr.all.length, 4)
+assert_eq(adr.v4s.length, 2)
+assert_eq(adr.v6s.length, 2)
+
+assert_eq(adr.first_ipv4, "192.168.0.1")
+assert_eq(adr.first_ipv6, "2001::/27")
+
+assert_eq(adr.dhcpv4?, false)
+adr.add_ip(DHCPV4)
+assert_eq(adr.dhcpv4?, true)
+
+assert_eq(adr.dhcpv6?, false)
+adr.add_ip(DHCPV6)
+assert_eq(adr.dhcpv6?, true)
+
+assert_eq(adr.loopback?, false)
+adr.add_ip(LOOPBACK)
+assert_eq(adr.loopback?, true)
+

data/lib/construqt/tests/test_bgps.rb

@@ -0,0 +1,24 @@
+
+Construqt::Bgps.add_as(93925993, "redistribute-connected" => true,
+                                 "redistribute-static" => true,
+                                 "redistribute-other-bgp" => true,
+                                 "description" => "test-93925993")
+
+Construqt::Bgps.add_as(73925993, "redistribute-connected" => true,
+                                 "redistribute-static" => true,
+                                 "redistribute-other-bgp" => true,
+                                 "description" => "test-73925993")
+
+Construqt::Bgps.connection("name_it",
+        "password" => "geheim",
+        "left" => {
+          "as" => Construqt::Bgps::find_as(93925993),
+          "my" => ipsec.left.interface,
+          "filter" => { "in" => Construqt::Bgps.find_filter('mgmt_net_in'), "out" => Construqt::Bgps.find_filter('mgmt_net_out') },
+        },
+        "right" => {
+          "as" => Construqt::Bgps::find_as(73925993),
+          "my" => ipsec.right.interface,
+          "filter" => { "in" => Construqt::Bgps.find_filter('mgmt_net_in'), "out" => Construqt::Bgps.find_filter('mgmt_net_out') },
+        }
+    )

data/lib/construqt/tests/test_hostid.rb

@@ -0,0 +1,32 @@
+
+
+id = Construqt::HostId.create do |block|
+  assert_eq(block.interfaces.length, 0)
+end
+
+assert_eq(id.first_ipv6!, nil)
+assert_eq(id.first_ipv4!, nil)
+
+begin
+  id.first_ipv4
+  assert("should not happend")
+raise
+end
+
+begin
+  id.first_ipv6
+  assert("should not happend")
+raise
+end
+
+iface = XXXXX
+id = Construqt::HostId.create do |block|
+  assert_eq(block.interfaces.length, 0)
+  block.interfaces << iface
+end
+
+assert_eq(id.first_ipv6!, iface.first_ipv6)
+assert_eq(id.first_ipv4!, iface.first_ipv4)
+
+assert_eq(id.first_ipv6, iface.first_ipv6)
+assert_eq(id.first_ipv4, iface.first_ipv4)

data/lib/construqt/tests/test_hosts.rb

@@ -0,0 +1,23 @@
+
+hosts = Hosts.new(19)
+
+assert_eq(hosts.region, 19)
+
+hosts.set_default_password("9339")
+assert_eq(hosts.default_password, "9339")
+
+assert_eq(hosts.get_hosts.length, 0)
+
+begin
+  hosts.add("test", "lutz" => "fuchs") do |host|
+  end
+end
+
+begin
+  hosts.add("test", "lutz" => "fuchs") do |host|
+  end
+  assert("Should not happend")
+raise
+end
+
+

data/lib/construqt/tests/test_utils.rb

@@ -0,0 +1,76 @@
+
+    class Test
+      include Chainable
+      #def initialize
+      #  puts ">>>test instance=#{"%x"%self.object_id} class=#{"%x"%self.class.object_id}"
+      #end
+      attr_reader :sideeffect
+      chainable_attr :bloed0
+      chainable_attr :bloed1
+      chainable_attr :test, 1, 2
+      chainable_attr :testbool, false, true
+      chainable_attr :testbool2, true, true
+      chainable_attr :testside, 1, 2, lambda {|i| @sideeffect ||= 9; @sideeffect += 1 }
+    end
+    class Test2
+      include Chainable
+      #def initialize
+      #  puts ">>>test instance=#{"%x"%self.object_id} class=#{"%x"%self.class.object_id}"
+      #end
+      attr_reader :sideeffect
+      chainable_attr :bloed0
+      chainable_attr :bloed1
+      chainable_attr :test, 3, 4
+      chainable_attr :testbool, true, false
+      chainable_attr :testside, 3, 4, lambda {|i| @sideeffect ||= 5; @sideeffect += 1 }
+    end
+    def self.test
+      3.times do |i|
+        t = Test.new
+        #throw "chainable failed input_only" unless t.input_only? == true
+        #throw "chainable failed output_only" unless t.output_only? == true
+
+        #puts "#{i}=>#{t.testbool?} #{t.testbool2?}"
+        throw "chainable failed test should 2 #{t.get_test.inspect}" if t.get_test != 2
+        t.test
+        throw "chainable failed this should be 1 " if t.get_test != 1
+        t.test(3)
+        throw "chainable failed" if t.get_test != 3
+
+        throw "chainable failed test should 2 #{t.get_testside.inspect}" if t.get_testside != 2
+        throw "chainable failed sideeffect should 1 nil #{t.sideeffect.inspect}" if !t.sideeffect.nil?
+        t.testside
+        throw "chainable failed this should be 1 " if t.get_testside != 1
+        throw "chainable failed sideeffect should 2 nil #{t.sideeffect.inspect}" if t.sideeffect != 10
+        t.testside(3)
+        throw "chainable failed" if t.get_testside != 3
+        throw "chainable failed sideeffect should 2 nil #{t.sideeffect.inspect}" if t.sideeffect != 11
+
+        throw "chainable failed true" unless t.testbool? == true
+        t.testbool
+        throw "chainable failed false" unless t.testbool? == false
+        t.testbool(4)
+        throw "chainable failed 4" unless t.testbool? == 4
+        t.testbool
+        throw "chainable failed false" unless t.testbool? == false
+
+        throw "chainable failed 2 true" unless t.testbool2? == true
+        t.testbool2
+        throw "chainable failed 2 false" unless t.testbool2? == true
+        t.testbool2(4)
+        throw "chainable failed 2 4" unless t.testbool2? == 4
+        t.testbool2
+        throw "chainable failed 2 false" unless t.testbool2? == true
+      end
+      a=[Test.new,Test.new,Test.new]
+      a[0].testbool(0)
+      throw "chainable failed 0" unless a[0].testbool? == 0
+      throw "chainable failed 1" unless a[1].testbool? == true
+      a[2].testbool
+      throw "chainable failed 2" unless a[2].testbool? == false
+
+      throw "chainable failed 0" unless a[0].testbool? == 0
+      throw "chainable failed 1" unless a[1].testbool? == true
+      throw "chainable failed 2" unless a[2].testbool? == false
+    end
+    @test = self.test

data/lib/construqt/users.rb

@@ -0,0 +1,19 @@
+module Construqt
+  class Users
+    def initialize(region)
+      @region = region
+      @users = {}
+    end
+
+    def add(name, cfg)
+      throw "user exists #{name}" if @users[name]
+      cfg['name'] = name
+      cfg['yubikey'] ||= nil
+      @users[name] = OpenStruct.new(cfg)
+    end
+
+    def all
+      @users.values
+    end
+  end
+end

data/lib/construqt/util.rb

@@ -0,0 +1,163 @@
+module Construqt
+  module Util
+    module Chainable
+
+      def self.included(other)
+        #puts "Chainable #{other.name}"
+        other.class.send("define_method", "chainable_attr") do |*args|
+          #puts "chainable_attr:#{self.name} #{args.inspect}"
+          Chainable.chainable_attr(self, *args)
+        end
+
+        other.class.send("define_method", "chainable_attr_value") do |*args|
+          #puts "chainable_attr_value:#{self.name} #{args.inspect}"
+          Chainable.chainable_attr_value(self, *args)
+        end
+      end
+
+      def self.chainable_attr_value(clazz, arg, init = nil)
+        instance_variable_name = "@#{arg}".to_sym
+        self.instance_variable_set(instance_variable_name, init)
+        define_method(arg.to_s) do |val|
+          self.instance_variable_set(instance_variable_name, val)
+          self
+        end
+
+        define_method("get_#{arg}") do
+          self.instance_variable_get(instance_variable_name.to_sym)
+        end
+      end
+
+      def self.chainable_attr(clazz, arg, set_value = true, init = false, aspect = lambda{|i|})
+        instance_variable_name = "@#{arg}".to_sym
+        #      puts ">>>chainable_attr #{"%x"%self.object_id} init=#{init}"
+        #      self.instance_variable_set(instance_variable_name, init)
+        #puts "self.chainable_attr #{clazz.name} #{arg.to_sym} #{set_value} #{init}"
+        clazz.send("define_method", arg.to_sym) do |*args|
+          instance_eval(&aspect)
+          self.instance_variable_set(instance_variable_name, args.length>0 ? args[0] : set_value)
+          self
+        end
+
+        if ((set_value.kind_of?(true.class) || set_value.kind_of?(false.class)) &&
+            (init.kind_of?(true.class) || init.kind_of?(false.class)))
+          get_name = "#{arg}?"
+        else
+          get_name = "get_#{arg}"
+        end
+
+        get_name_proc = Proc.new do
+          unless self.instance_variables.include?(instance_variable_name)
+            #puts "init #{get_name} #{instance_variable_name} #{defined?(instance_variable_name)} #{set_value} #{init}"
+            self.instance_variable_set(instance_variable_name, init)
+          end
+
+          ret = self.instance_variable_get(instance_variable_name)
+          #puts "#{self.class.name} #{get_name} #{set_value} #{init} => #{ret.inspect}"
+          ret
+        end
+
+        clazz.send("define_method", get_name, get_name_proc)
+      end
+    end
+
+    def self.write_str(str, *path)
+      path = File.join("cfgs", *path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w') {|f| f.write(str) }
+      Construqt.logger.info "Write:#{path}"
+      return str
+    end
+
+    def self.password(a)
+      a
+    end
+
+    def self.add_gre_prefix(name)
+      unless name.start_with?("gt")
+        return "gt"+name
+      end
+
+      name
+    end
+
+    @clean_if = []
+    def self.add_clean_ip_pattern(pat)
+      @clean_if << pat
+    end
+
+    def self.clean_if(prefix, name)
+      unless name.start_with?(prefix)
+        name = prefix+name
+      end
+
+      name = name.gsub(/[^a-z0-9]/, '')
+      @clean_if.each { |pat| name.gsub!(pat, '') }
+      name
+    end
+
+    def self.clean_bgp(name)
+      name.gsub(/[^a-z0-9]/, '_')
+    end
+
+    def self.portNeighbors?(port1, port2)
+      port2.succ == port1 || port1.succ == port2
+    end
+
+    def self.createRangeDefinition(ports)
+      ranges=[]
+      lastPort=nil
+
+      #remove duplicates
+      ports.uniq.sort do |l,r|
+        fc = l.to_s.length <=> r.to_s.length
+        fc!=0 ? fc : l<=>r
+      end.each do |port|
+        port = port.to_s
+        if  (ranges.length>0 && portNeighbors?(port, ranges[ranges.length-1]["to"]))
+          ranges[ranges.length-1]["to"] = port
+        else
+          ranges << {"from" => port, "to" => port}
+        end
+      end
+
+      ranges = ranges.map do |range|
+        range["from"] == range["to"] ? range["from"] : range["from"] +"-"+range["to"]
+      end
+      #puts "self.createRangeDefinition[#{ports}]=>#{ranges}"
+      ranges.join(",")
+    end
+
+    PORTS_DEF_REGEXP = "([^\\d\\s]*[\\d,-]+)+"
+    PORT_NAME_REGEXP="^(.*?)(\\d+)$"
+    def self.expandRangeDefinition(list_str)
+      ports = list_str.strip.split(",").map do |range_def|
+        range = range_def.split("-")
+        if (range.length==1)
+          range
+        elsif (range.length==2)
+          range[0]=~/#{PORT_NAME_REGEXP}/
+          prefix_from=$1
+          from = $2
+          range[1]=~/#{PORT_NAME_REGEXP}/
+          prefix_to=$1
+          to = $2
+          throw "port prefixes differ" unless prefix_from==prefix_to
+          (from.to_i .. to.to_i).map {|n| prefix_from + n.to_s }
+        else
+          throw "invalid range found #{range_def}"
+        end
+      end
+      ports.flatten
+    end
+
+    def self.generate_mac_address_from_name(name)
+      # http://www.iana.org/assignments/ethernet-numbers/ethernet-numbers.xhtml
+      '8f:'+Digest::SHA256.hexdigest("#{name}").scan(/../)[0,5].join(':')
+    end
+
+    def self.indent(body, ident)
+      body.lines.map { |line| ident+line }.join("\n")
+    end
+  end
+end

data/lib/construqt/version.rb

@@ -0,0 +1,3 @@
+module Construqt
+  VERSION = "0.0.1"
+end

data/lib/construqt/vlans.rb

@@ -0,0 +1,51 @@
+
+module Construqt
+  class Vlans
+    def initialize(region)
+      @region = region
+      @vlans_id = {}
+      @vlans_description = {}
+    end
+
+    class Vlan < OpenStruct
+      def initialize(cfg)
+        super(cfg)
+      end
+
+      def tagged?
+        @tagged
+      end
+
+      def tagged
+        @tagged=true
+        self
+      end
+
+      def untagged?
+        !@tagged
+      end
+
+      def untagged
+        @tagged = false
+        self
+      end
+    end
+
+    def add(vlan, cfg)
+      throw "vlan has to be a fixnum #{vlan}" unless vlan.kind_of?(Fixnum)
+      throw "vlan need #{vlan} description" unless cfg['description']
+      throw "vlan with id #{vlan} exists" if @vlans_id[vlan]
+      throw "vlan with description #{vlan} exists" if @vlans_description[cfg['description']]
+      cfg['vlan_id'] = vlan
+      ret = Vlan.new(cfg)
+      @vlans_id[vlan] = ret
+      @vlans_description[cfg['description']] = ret
+      ret
+    end
+
+    def clone(key)
+      throw "vlan clone key not found #{key}" unless @vlans_id[key] || @vlans_description[key]
+      (@vlans_id[key] || @vlans_description[key]).clone
+    end
+  end
+end

data/lib/construqt.rb

@@ -0,0 +1,92 @@
+require 'logger'
+
+require 'fileutils'
+require 'ostruct'
+
+require 'ipaddress'
+require 'digest/sha1'
+require 'digest/md5'
+require "base64"
+require 'securerandom'
+
+
+module Construqt
+
+  @logger = Logger.new(STDOUT)
+  @logger.level = Logger::DEBUG
+
+  def self.log_level(level)
+    @logger.level = level
+  end
+
+  if !IPAddress::IPv6.instance_methods.include?(:rev_domains)
+    @logger.fatal "you need the right ipaddress version from https://github.com/mabels/ipaddress"
+  end
+
+  if !OpenStruct.instance_methods.include?(:to_h)
+    OpenStruct.class_eval do
+      def to_h
+        @table.dup
+      end
+    end
+
+    @logger.warn "Your running a patched version of OpenStruct"
+  end
+
+  def self.logger
+    @logger
+  end
+
+  # ugly but i need the logger during initialization
+  require_relative 'construqt/util.rb'
+  require_relative 'construqt/services.rb'
+  require_relative 'construqt/networks.rb'
+  require_relative 'construqt/addresses.rb'
+  require_relative 'construqt/bgps.rb'
+  require_relative 'construqt/users.rb'
+  require_relative 'construqt/firewalls.rb'
+  require_relative 'construqt/flavour/delegates.rb'
+  require_relative 'construqt/resource.rb'
+  require_relative 'construqt/hostid.rb'
+  require_relative 'construqt/hosts.rb'
+  require_relative 'construqt/interfaces.rb'
+  require_relative 'construqt/cables.rb'
+  require_relative 'construqt/ipsecs.rb'
+  require_relative 'construqt/firewalls.rb'
+  require_relative 'construqt/templates.rb'
+  require_relative 'construqt/regions.rb'
+  require_relative 'construqt/vlans.rb'
+  require_relative 'construqt/tags.rb'
+  require_relative 'construqt/flavour/flavour.rb'
+
+  require_relative 'construqt/flavour/unknown/unknown.rb'
+  [
+    'construqt/flavour/ciscian/ciscian.rb',
+    'construqt/flavour/plantuml/plantuml.rb',
+    'construqt/flavour/mikrotik/flavour_mikrotik.rb',
+    'construqt/flavour/ubuntu/flavour_ubuntu.rb'].each do |fname|
+      begin
+        require_relative fname
+      rescue LoadError
+        Construqt::logger.warn("can not load driver:#{fname}")
+      end
+    end
+
+    def self.produce(region_or_hosts)
+      hosts = false
+      hosts = region_or_hosts if region_or_hosts.kind_of?(Array)
+      hosts = region_or_hosts.hosts.get_hosts if region_or_hosts.kind_of?(Construqt::Regions::Region)
+      throw "need a region or hosts list" unless hosts
+      Construqt::Ipsecs.build_config()
+      Construqt::Bgps.build_config()
+      hosts.inject({}) do |r, host|
+        r[host.region.name] ||= []
+        r[host.region.name] << host
+        r
+      end.values.each do |hosts|
+        hosts.first.region.hosts.build_config(hosts)
+        hosts.first.region.interfaces.build_config(hosts)
+        hosts.first.region.hosts.commit(hosts)
+      end
+    end
+end