construqt 0.0.1

data/lib/construqt/flavour/unknown/unknown.rb

@@ -0,0 +1,175 @@
+
+module Construqt
+  module Flavour
+    module Unknown
+      def self.name
+        'unknown'
+      end
+
+      Construqt::Flavour.add(self)
+
+      class Device < OpenStruct
+        def initialize(cfg)
+          super(cfg)
+        end
+
+        def build_config(host, iface)
+        end
+      end
+
+      class Vrrp < OpenStruct
+        def initialize(cfg)
+          super(cfg)
+        end
+
+        def build_config(host, iface)
+        end
+      end
+
+      class Bond < OpenStruct
+        def initialize(cfg)
+          super(cfg)
+        end
+
+        def build_config(host, iface)
+        end
+      end
+
+      class Vlan < OpenStruct
+        def initialize(cfg)
+          super(cfg)
+        end
+
+        def build_config(host, iface)
+        end
+      end
+
+      class Bridge < OpenStruct
+        def initialize(cfg)
+          super(cfg)
+        end
+
+        def build_config(host, iface)
+        end
+      end
+
+      class Host < OpenStruct
+        def initialize(cfg)
+          super(cfg)
+        end
+
+        def header(host)
+        end
+
+        def footer(host)
+        end
+
+        def build_config(host, unused)
+        end
+      end
+
+      class Gre < OpenStruct
+        def initialize(cfg)
+          super(cfg)
+        end
+
+        def build_config(host, iface)
+        end
+      end
+
+      class Opvn < OpenStruct
+        def initialize(cfg)
+          super(cfg)
+        end
+
+        def build_config(host, iface)
+        end
+      end
+
+      class Template
+        def initialize(cfg)
+          super(cfg)
+        end
+      end
+
+      class Result
+        def initialize(host)
+        end
+
+        def commit
+        end
+      end
+
+      #	class Interface < OpenStruct
+      #		def initialize(cfg)
+      #      super(cfg)
+      #		end
+
+      #		def build_config(host, iface)
+      #      self.clazz.build_config(host, iface||self)
+      #		end
+
+      #	end
+      #
+      def self.clazzes
+        {
+          "opvn" => Opvn,
+          "gre" => Gre,
+          "host" => Host,
+          "device"=> Device,
+          "vrrp" => Vrrp,
+          "bridge" => Bridge,
+          "template" => Template,
+          "bond" => Bond,
+          "vlan" => Vlan,
+          "result" => Result
+        }
+      end
+
+      def self.clazz(name)
+        ret = self.clazzes[name]
+        throw "class not found #{name}" unless ret
+        ret
+      end
+
+      def self.create_host(name, cfg)
+        cfg['name'] = name
+        cfg['result'] = nil
+        host = Host.new(cfg)
+        host.result = Result.new(host)
+        host
+      end
+
+      def self.create_interface(name, cfg)
+        cfg['name'] = name
+        clazz(cfg['clazz']).new(cfg)
+      end
+
+      class Bgp < OpenStruct
+        def initialize(cfg)
+          super(cfg)
+        end
+
+        def build_config(unused, unused1)
+        end
+      end
+
+      def self.create_bgp(cfg)
+        Bgp.new(cfg)
+      end
+
+      class Ipsec < OpenStruct
+        def initialize(cfg)
+          super(cfg)
+        end
+
+        def build_config(unused, unused1)
+        end
+      end
+
+      def self.create_ipsec(cfg)
+        Ipsec.new(cfg)
+      end
+    end
+  end
+end

data/lib/construqt/hostid.rb

@@ -0,0 +1,42 @@
+module Construqt
+
+  class HostId
+    attr_accessor :interfaces
+    def self.create(&block)
+      a = HostId.new()
+      a.interfaces=[]
+      block.call(a)
+      return a
+    end
+
+    def first_ipv6!
+      self.interfaces.each do |i|
+        next unless i.address
+        return i.address if i.address.first_ipv6
+      end
+
+      nil
+    end
+
+    def first_ipv6
+      ret = first_ipv6!
+      throw "first_ipv6 failed #{self.interfaces.first.host.name}" unless ret
+      ret
+    end
+
+    def first_ipv4!
+      self.interfaces.each do |i|
+        next unless i.address
+        return i.address if i.address.first_ipv4
+      end
+
+      nil
+    end
+
+    def first_ipv4
+      ret = first_ipv4!
+      throw "first_ipv4 failed #{self.interfaces.first.host.name}" unless ret
+      ret
+    end
+  end
+end

data/lib/construqt/hosts.rb

@@ -0,0 +1,98 @@
+
+module Construqt
+
+  class Hosts
+
+    def initialize(region)
+      @region = region
+      @hosts = {}
+      @default_pwd = SecureRandom.urlsafe_base64(24)
+    end
+
+    def region
+      @region
+    end
+
+    def set_default_password(pwd)
+      @default_pwd = pwd
+    end
+
+    def default_password
+      @default_pwd
+    end
+
+    def get_hosts()
+      @hosts.values
+    end
+
+    def del(name)
+      host = @hosts[name]
+      return nil unless host
+      @hosts.delete(name)
+      host
+    end
+
+    def add(host_name, cfg, &block)
+      (host_name, host) = Construqt::Tags.add(host_name) { |name| add_internal(name, cfg) { |h| block.call(h) } }
+      host
+    end
+
+    def add_internal(name, cfg, &block)
+      #binding.pry
+      throw "id is not allowed" if cfg['id']
+      throw "configip is not allowed" if cfg['configip']
+      throw "Host with the name #{name} exisits" if @hosts[name]
+      cfg['interfaces'] = {}
+      cfg['id'] ||=nil
+      cfg['configip'] ||=nil
+
+      cfg['name'] = name
+      cfg['dns_server'] ||= false
+      cfg['result'] = nil
+      cfg['shadow'] ||= nil
+      cfg['flavour'] = Flavour.find(cfg['flavour'] || 'ubuntu')
+      #		cfg['clazz'] = cfg['flavour'].clazz("host")
+      throw "flavour #{cfg['flavour']} for host #{name} not found" unless cfg['flavour']
+      cfg['region'] = @region
+      host = cfg['flavour'].create_host(name, cfg)
+      block.call(host)
+      throw "host attribute id is required" unless host.id.kind_of? HostId
+      throw "host attribute configip is required" unless host.configip.kind_of? HostId
+
+      if (host.id.first_ipv4! && !host.id.first_ipv4!.dhcpv4?) ||
+          (host.id.first_ipv6! && !host.id.first_ipv6!.dhcpv6?)
+        adr = nil
+        if host.id.first_ipv4!
+          adr = (adr || region.network.addresses.create).add_ip(host.id.first_ipv4.first_ipv4.to_s).set_name(host.name)
+        end
+
+        if host.id.first_ipv6!
+          adr = (adr || region.network.addresses.create).add_ip(host.id.first_ipv6.first_ipv6.to_s).set_name(host.name)
+        end
+
+        adr = region.network.addresses.create unless adr
+        adr.host = host if adr
+      end
+
+      @hosts[name] = host
+    end
+
+    def find(name)
+      ret = @hosts[name]
+      throw "host not found #{name}" unless ret
+      ret
+    end
+
+    def build_config(hosts = nil)
+      (hosts || @hosts.values).each do |host|
+        host.build_config(host, nil)
+      end
+    end
+
+    def commit(hosts = nil)
+      (hosts || @hosts.values).each { |h| h.commit }
+      Flavour.call_aspects("completed", nil, nil)
+    end
+  end
+
+end

data/lib/construqt/interfaces.rb

@@ -0,0 +1,166 @@
+module Construqt
+  class Interfaces
+    def initialize(region)
+      @region = region
+    end
+
+    def setup_template(iface)
+      iface.template.vlans.each do |vlan|
+
+        vname = vlan.description
+        to_add_iface = iface.host.interfaces[vname]
+        unless to_add_iface
+          to_add_iface = add_vlan(iface.host, vname, vlan.to_h.inject({}){|r,(k,v)| r[k.to_s]=v; r })
+        end
+
+        #puts ">>>>>#{iface.name}"
+        to_add_iface.interfaces << iface
+      end
+    end
+
+    def add_device(host, dev_name, cfg)
+      throw "Host not found:#{dev_name}" unless host
+      throw "Interface is duplicated:#{host.name}:#{dev_name}" if host.interfaces[dev_name]
+      throw "invalid name #{dev_name}" unless dev_name.match(/^[A-Za-z0-9\-\.]+$/)
+      if match=/^.*[^\d](\d+)$/.match(dev_name)
+        cfg['number'] ||= match[1].to_i
+      end
+
+      cfg['host'] = host
+      cfg['mtu'] ||= 1500
+      #binding.pry if host && host.name == "ct-iar1-ham"
+      #    binding.pry
+      cfg['clazz'] ||= "device"
+      cfg['address'] ||= nil
+      (dev_name, iface) = Construqt::Tags.add(dev_name) { |name| host.flavour.create_interface(name, cfg) }
+      #    iface.clazz.attach = iface
+      host.interfaces[dev_name] = iface
+      host.interfaces[dev_name].address.interface = host.interfaces[dev_name] if host.interfaces[dev_name].address
+      setup_template(iface) if iface.template
+      host.interfaces[dev_name]
+    end
+
+#    def add_template(host, name, cfg)
+#     cfg['clazz'] = "template"
+#    cfg['host'] = host
+#   cfg['name'] = name
+#      self.add_device(host,name, cfg)
+#    end
+
+    def add_openvpn(host, name, cfg)
+      cfg['clazz'] = "opvn"
+      cfg['ipv6'] ||= nil
+      cfg['ipv4'] ||= nil
+      dev = add_device(host, name, cfg)
+      dev.address.interface = host.interfaces[name] if dev.address
+      dev.network.name = "#{name}-#{host.name}"
+      dev
+    end
+
+    def add_gre(host, name, cfg)
+      throw "we need an address on this cfg #{cfg.inspect}" unless cfg['address']
+      cfg['clazz'] = "gre"
+      cfg['local'] ||= nil
+      cfg['remote'] ||= nil
+      dev = add_device(host, name, cfg)
+      dev.address.interface = host.interfaces[name] if dev.address
+      dev
+    end
+
+    def add_vlan(host, name, cfg)
+      unless cfg["vlan_id"].to_s.match(/^[0-9]+$/) && 1 <= cfg["vlan_id"].to_i && cfg["vlan_id"].to_i < 4096
+        throw "vlan_id must be set on vlan with name #{name}"
+      end
+      cfg = cfg.clone
+      interfaces = cfg['interfaces'] || []
+      interfaces << cfg['interface'] if cfg['interface']
+      cfg.delete('interface')
+      cfg['interfaces'] = interfaces
+      #    throw "we need an interface #{cfg['interfaces']}" if cfg['interfaces'].empty?
+      cfg['clazz'] = "vlan"
+      dev = add_device(host, name, cfg)
+      dev.address.interface = host.interfaces[name] if dev.address
+      dev
+    end
+
+    def add_bond(host, name, cfg)
+      cfg['interfaces'].each do |interface|
+        throw "interface not one same host:#{interface.host.name}:#{host.name}" unless host.name == interface.host.name
+      end
+
+      cfg['clazz'] = "bond"
+      dev = add_device(host, name, cfg)
+      dev.address.interface = host.interfaces[name] if dev.address
+      dev
+    end
+
+    def add_vrrp(name, cfg)
+      nets = {}
+      cfg['address'].ips.each do |adr|
+        throw "only host ip's are allowed #{adr.to_s}" if adr.ipv4? && adr.prefix != 32
+        throw "only host ip's are allowed #{adr.to_s}" if adr.ipv6? && adr.prefix != 128
+        nets[adr.network.to_s] = true
+      end
+
+      cfg['interfaces'].each do |interface|
+        throw "interface need priority #{interface}" unless interface.priority
+        throw "interface not found:#{name}" unless interface
+        cfg['clazz'] = "vrrp"
+        cfg['interface'] = interface
+        throw "vrrp interface does not have within the same network" if nets.length == interface.address.ips.select { |adr| nets[adr.network.to_s] }.length
+        dev = add_device(interface.host, name, cfg)
+        dev.address.interface = nil
+        dev.address.host = nil
+        dev.address.name = name
+      end
+    end
+
+    def add_bridge(host, name, cfg)
+      #cfg['interfaces'] = []
+      cfg['interfaces'].each do |interface|
+        throw "interface not one same host:#{interface.host.name}:#{host.name}" unless host.name == interface.host.name
+      end
+
+      cfg['clazz'] = "bridge"
+      dev = add_device(host, name, cfg)
+      dev.address.interface = host.interfaces[name] if dev.address
+      dev
+    end
+
+    def find(host_or_name, iface_name)
+      if host_or_name.kind_of?(String)
+        host = @region.hosts.find(host_or_name)
+        throw "host not found #{host_or_name}" unless host
+      else
+        host = host_or_name
+      end
+
+      iface = host.interfaces[iface_name]
+      throw "interface not found for #{iface_name}:#{host.name}" unless iface
+      iface
+    end
+
+    def build_config(hosts = nil)
+      (hosts||Hosts.get_hosts).each do |host|
+        by_clazz = {}
+        host.interfaces.values.each do |interface|
+          #throw "class less interface #{interface.inspect}" unless interface.clazz
+          #throw "no clazz defined in interface #{interface.clazz}" unless interface.clazz.name
+          name = interface.clazz # .name[interface.clazz.name.rindex(':')+1..-1].downcase
+          #puts "<<<<<<< #{name}"
+          by_clazz[name] ||= []
+          by_clazz[name] << interface
+        end
+
+        #binding.pry
+        ["host", "device", "vlan", "bond", "bridge", "vrrp", "gre", "bgp", "opvn", "ipsec"].each do |key|
+          next unless by_clazz[key]
+          by_clazz[key].each do |interface|
+            #Construqt.logger.debug "Interface:build_config:#{interface.name}:#{interface.class.name}:#{interface.ident}"
+            interface.build_config(host, interface)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/construqt/ipsecs.rb

@@ -0,0 +1,64 @@
+
+module Construqt
+  module Ipsecs
+    class Ipsec < OpenStruct
+      def initialize(cfg)
+        super(cfg)
+      end
+
+      def build_config()
+        self.left.build_config(nil, nil)
+        self.right.build_config(nil, nil)
+      end
+
+      def ident
+        self.left.ident
+      end
+    end
+
+    @ipsecs = {}
+    def self.add_connection(cfg, id, to_id, iname)
+      throw "my not found #{cfg[id].inspect}" unless cfg[id]['my']
+      throw "host not found #{cfg[id].inspect}" unless cfg[id]['host']
+      throw "remote not found #{cfg[id].inspect}" unless cfg[id]['remote']
+      cfg[id]['other'] = nil
+      cfg[id]['cfg'] = nil
+      cfg[id]['my'].host = cfg[id]['host']
+      cfg[id]['my'].name = "#{iname}-#{cfg[id]['host'].name}"
+      cfg[id]['interface'] = nil
+      cfg[id] = cfg[id]['host'].flavour.create_ipsec(cfg[id])
+    end
+
+    def self.connection(name, cfg)
+      #    binding.pry
+      add_connection(cfg, 'left', 'right', Util.add_gre_prefix(cfg['right']['host'].name))
+      add_connection(cfg, 'right', 'left', Util.add_gre_prefix(cfg['left'].host.name))
+      cfg['name'] = name
+      cfg = @ipsecs[name] = Ipsec.new(cfg)
+      cfg.left.other = cfg.right
+      cfg.left.cfg = cfg
+      cfg.right.other = cfg.left
+      cfg.right.cfg = cfg
+
+      #puts "-------- #{cfg.left.my.host.name} - #{cfg.right.my.host.name}"
+      cfg.left.interface = cfg.left.my.host.region.interfaces.add_gre(cfg.left.my.host, cfg.left.other.host.name,
+                                                                      "address" => cfg.left.my,
+                                                                      "local" => cfg.left.remote,
+                                                                      "remote" => cfg.right.remote
+                                                                     )
+      cfg.right.interface = cfg.left.my.host.region.interfaces.add_gre(cfg.right.my.host, cfg.right.other.host.name,
+                                                                       "address" => cfg.right.my,
+                                                                       "local" => cfg.right.remote,
+                                                                       "remote" => cfg.left.remote
+                                                                      )
+      #binding.pry
+      cfg
+    end
+
+    def self.build_config()
+      @ipsecs.each do |name, ipsec|
+        ipsec.build_config()
+      end
+    end
+  end
+end

data/lib/construqt/networks.rb

@@ -0,0 +1,81 @@
+module Construqt
+  module Networks
+
+    class Network
+      def initialize(name)
+        @name = name
+        @networks = []
+        @domain = "construqt.org"
+        @contact = "soa@construqt.org"
+        @addresses = Construqt::Addresses.new(self)
+        @services = Construqt::Services.new
+        @dns_resolver = nil
+      end
+
+      def services
+        @services
+      end
+
+      def addresses
+        @addresses
+      end
+
+      def add_blocks(*nets)
+        nets.each do |net|
+          @networks << IPAddress.parse(net)
+        end
+      end
+
+      def networks
+        @networks
+      end
+
+      def to_network(ip)
+        ret = (@networks.find{ |my| (ip.ipv6? == my.ipv6? && ip.ipv4? == my.ipv4?) && my.include?(ip) } || ip.network)
+        ret
+      end
+
+      def set_dns_resolver(nameservers, search)
+        @dns_resolver = OpenStruct.new :nameservers => nameservers, :search => search
+      end
+
+      def dns_resolver
+        @dns_resolver
+      end
+
+      def set_domain(domain)
+        @domain = domain
+      end
+
+      def domain
+        @domain
+      end
+
+      def set_contact(contact)
+        @contact = contact
+      end
+
+      def contact
+        @contact
+      end
+
+      #    def domain(name)
+      #      _fqdn = self.fqdn(name)
+      #      _fqdn[_fqdn.index('.')+1..-1]
+      #    end
+
+      def fqdn(name)
+        throw "name must set" unless name
+        _name = name.gsub(/[\s_]+/, '-')
+        return "#{_name}.#{self.domain}" unless _name.include?('.')
+        return _name
+      end
+    end
+
+    @networks = {}
+    def self.add(name)
+      throw "network with name #{name} exists" if @networks[name]
+      @networks[name] = Network.new(name)
+    end
+  end
+end

data/lib/construqt/regions.rb

@@ -0,0 +1,32 @@
+
+module Construqt
+  module Regions
+    @regions = {}
+    class Region
+      attr_reader :name, :cables, :hosts, :interfaces, :users, :vlans, :network, :templates, :resources
+      def initialize(name, network)
+        @name = name
+        @network = network
+        @vlans = Construqt::Vlans.new(self)
+        @hosts = Construqt::Hosts.new(self)
+        @interfaces = Construqt::Interfaces.new(self)
+        @templates = Construqt::Templates.new(self)
+        @users = Construqt::Users.new(self)
+        @cables = Construqt::Cables.new(self)
+        @resources = Construqt::Resources.new(self)
+      end
+    end
+
+    def self.add(name, network)
+      throw "region names #{name} has to be unique" if @regions[name]
+      ret = Region.new(name, network)
+      @regions[name] = ret
+      ret
+    end
+
+    def self.find(name)
+      throw "region with name #{name} not found" unless @regions[name]
+      @regions[name]
+    end
+  end
+end

data/lib/construqt/resource.rb

@@ -0,0 +1,42 @@
+module Construqt
+  class Resources
+    module Rights
+      ROOT_0600 = OpenStruct.new :right => "0600", :owner => 'root'
+      ROOT_0644 = OpenStruct.new :right => "0644", :owner => 'root'
+      ROOT_0755 = OpenStruct.new :right => "0755", :owner => 'root'
+    end
+
+    class Resource
+      attr_accessor :path
+      attr_accessor :right
+      attr_accessor :data
+    end
+
+    def initialize(region)
+      @region = region
+      @files = {}
+    end
+
+    def add_from_file(src_fname, right, key, *path)
+      add_file(IO.read(src_fname), right, key, *path)
+    end
+
+    def add_file(data, right, key, *path)
+      throw "need a key" unless key
+      throw "need a path #{key}" if path.empty?
+      throw "resource exists with key #{key}" if @files[key]
+      resource = Resource.new
+      resource.path = *path
+      resource.right = right
+      resource.data = data
+      @files[key] = resource
+      resource
+    end
+
+    def find(key)
+      ret = @files[key]
+      throw "resource with key #{key} not found" unless ret
+      ret
+    end
+  end
+end