construqt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ec8fbada65d807c3b03a0659270b3574e274fce
+  data.tar.gz: 021691f9b160814aa6cd08580b0888337f1d8160
+SHA512:
+  metadata.gz: cd0256802fca445d8739ba16c613a936664144cb19162ad0c09bc4b91b0e8b27b3522d304647d2b23283812c3b2843db1ee22dd376175c48310bc57eea78c1f2
+  data.tar.gz: e46c4967d8df48ed987ccf52b553ba2ecfb1ba4ff2c988947798f44a8ae2603c747c99bcc764776950dbefaa695034671994dbe0b1c3652b66800664986c77e9

data/lib/construqt/addresses.rb

@@ -0,0 +1,204 @@
+
+module Construqt
+  class Addresses
+
+    UNREACHABLE = :unreachable
+    LOOOPBACK = :looopback
+    DHCPV4 = :dhcpv4
+    DHCPV6 = :dhcpv6
+    IPV4 = :ipv4
+    IPV6 = :ipv6
+
+    def initialize(network)
+      @network = network
+      @Addresses = []
+    end
+
+    def network
+      @network
+    end
+
+    class Address
+      attr_accessor :host
+      attr_accessor :interface
+      attr_accessor :ips
+      attr_accessor :tags
+      def dhcpv4?
+        @dhcpv4
+      end
+
+      def dhcpv6?
+        @dhcpv6
+      end
+
+      def loopback?
+        @loopback
+      end
+
+      def initialize()
+        self.ips = []
+        self.host = nil
+        self.interface = nil
+        self.routes = []
+        self.tags = []
+        @loopback = @dhcpv4 = @dhcpv6 = false
+        @name = nil
+      end
+
+      def match_network(ip)
+        if ip.ipv4?
+          self.v4s.find{|nip| nip.include?(ip) }
+        else
+          self.v6s.find{|nip| nip.include?(ip) }
+        end
+      end
+
+      def v6s
+        self.ips.select{|ip| ip.ipv6? }
+      end
+
+      def v4s
+        self.ips.select{|ip| ip.ipv4? }
+      end
+
+      def first_ipv4
+        v4s.first
+      end
+
+      def first_ipv6
+        v6s.first
+      end
+
+      def merge_tag(name, &block)
+        Construqt::Tags.add(([name]+self.tags).join("#")) { |name| block.call(name) }
+      end
+
+      def tag(tag)
+        self.tags << tag
+        self
+      end
+
+      def set_name(xname)
+        (@name, obj) = self.merge_tag(xname) { |xname| self }
+        self
+      end
+
+      def name=(name)
+        set_name(name)
+      end
+
+      def name
+        ret = self.name!
+        throw "unreferenced address [#{self.ips.map{|i| i.to_string }}]" unless ret
+        ret
+      end
+
+      def name!
+        return @name if @name
+        return "#{self.interface.name}-#{self.interface.host.name}" if self.interface
+        return self.host.name if self.host
+        nil
+      end
+
+      def add_ip(ip, region = "")
+        throw "please give a ip #{ip}" unless ip
+        if ip
+          #puts ">>>>> #{ip} #{ip.class.name}"
+          if DHCPV4 == ip
+            @dhcpv4 = true
+          elsif DHCPV6 == ip
+            @dhcpv6 = true
+          elsif LOOOPBACK == ip
+            @loopback = true
+          else
+            (unused, ip) = self.merge_tag(ip) { |ip| IPAddress.parse(ip) }
+            self.ips << ip
+          end
+        end
+
+        self
+      end
+
+      #    @nameservers = []
+      #    def add_nameserver(ip)
+      #      @nameservers << IPAddress.parse(ip)
+      #      self
+      #    end
+
+      attr_accessor :routes
+      def add_routes(addr_s, via, options = {})
+        addrs = addr_s.kind_of?(Array) ? addr_s : [addr_s]
+        addrs.each{|addr| addr.ips.each {|i| add_route(i.to_string, via, options) } }
+        self
+      end
+
+      def add_route(dst, via, option = {})
+        #puts "DST => "+dst.class.name+":"+dst.to_s
+        (unused, dst) = self.merge_tag(dst) { |dst| IPAddress.parse(dst) }
+        metric = option['metric']
+        if via == UNREACHABLE
+          via = nil
+          type = 'unreachable'
+        else
+          if via.nil?
+            via = nil
+          else
+            via = IPAddress.parse(via)
+            throw "different type #{dst} #{via}" unless dst.ipv4? == via.ipv4? && dst.ipv6? == via.ipv6?
+          end
+
+          type = nil
+        end
+
+        self.routes << OpenStruct.new("dst" => dst, "via" => via, "type" => type, "metric" => metric)
+        self
+      end
+
+      def to_s
+        "<Address:Address #{@name}=>#{self.ips.map{|i| i.to_s}.join(":")}>"
+      end
+    end
+
+    def create
+      ret = Address.new()
+      @Addresses << ret
+      ret
+    end
+
+    def tag(tag)
+      create.tag(tag)
+    end
+
+    def add_ip(ip, region = "")
+      create.add_ip(ip, region)
+    end
+
+    def add_route(dest, via = nil)
+      create.add_route(dest, via)
+    end
+
+    def set_name(name)
+      create.set_name(name)
+    end
+
+    def all
+      @Addresses
+    end
+
+    def v4_default_route(tag = "")
+      nets = [(1..9),(11..126),(128..168),(170..171),(173..191),(193..223)].map do |range|
+        range.to_a.map{|i| "#{i}.0.0.0/8"}
+      end.flatten
+      nets += (0..255).to_a.select{|i| i!=254}.map{|i| "169.#{i}.0.0/16" }
+      nets += (0..255).to_a.select{|i| !(16<=i&&i<31)}.map{|i| "172.#{i}.0.0/16" }
+      nets += (0..255).to_a.select{|i| i!=168}.map{|i| "192.#{i}.0.0/16" }
+
+      v4_default_route = self.create
+      v4_default_route.set_name(tag).tag(tag) if tag && !tag.empty?
+      IPAddress::IPv4::summarize(*(nets.map{|i| IPAddress::IPv4.new(i) })).each do |i|
+        v4_default_route.add_ip(i.to_string)
+      end
+      v4_default_route
+    end
+  end
+end

data/lib/construqt/bgps.rb

@@ -0,0 +1,164 @@
+module Construqt
+  module Bgps
+    class Bgp < 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
+
+    @bgps = {}
+    def self.connections
+      @bgps.values
+    end
+
+    def self.add_connection(cfg, id)
+      throw "my not found #{cfg[id]['my'].inspect}" unless cfg[id]['my']
+      throw "as not found #{cfg[id]['as'].inspect}" unless cfg[id]['as']
+      throw "as not a as #{cfg[id]['as'].inspect}" unless cfg[id]['as'].kind_of?(As)
+      #throw "filter not found #{cfg.inspect}" unless cfg[id]['filter']
+      cfg[id]['filter'] ||= {}
+      cfg[id]['other'] = nil
+      cfg[id]['cfg'] = nil
+      cfg[id]['host'] = cfg[id]['my'].host
+      cfg[id] = cfg[id]['host'].flavour.create_bgp(cfg[id])
+    end
+
+    def self.connection(name, cfg)
+      throw "filter not allowed" if cfg['filter']
+      throw "duplicated name #{name}" if @bgps[name]
+      add_connection(cfg, 'left')
+      add_connection(cfg, 'right')
+      cfg['name'] = name
+
+      cfg = @bgps[name] = Bgp.new(cfg)
+      cfg.left.other = cfg.right
+      cfg.left.cfg = cfg
+      cfg.right.other = cfg.left
+      cfg.right.cfg = cfg
+      cfg
+    end
+
+    def self.build_config()
+      #binding.pry
+      hosts = {}
+      @bgps.each do |name, bgp|
+        bgp.build_config()
+        hosts[bgp.left.host.name] = bgp.left
+        hosts[bgp.right.host.name] = bgp.right
+      end
+
+      #hosts.values.each do |flavour_bgp|
+      #  flavour_bgp.header(flavour_bgp.host)
+      #  flavour_bgp.footer(flavour_bgp.host)
+      #end
+    end
+
+    @filters = {}
+
+    class Filter
+      def initialize(name)
+        @name = name
+        @list = []
+      end
+
+      def list
+        @list
+      end
+
+      def name
+        @name
+      end
+
+      def addr_v_(cfg)
+        [OpenStruct.new({:code=>4, :is? => lambda {|i| i.ipv4? }, :max_prefix=>32}),
+         OpenStruct.new({:code=>6, :is? => lambda {|i| i.ipv6? }, :max_prefix=>128})].each do |family|
+          addr = cfg["addr_v#{family.code}"]
+          next unless addr
+          cfg.delete("addr_v#{family.code}")
+          addr_sub_prefix = cfg['addr_sub_prefix']
+          cfg.delete('addr_sub_prefix')
+          #puts addr.inspect
+          (addr.kind_of?(Construqt::Addresses::Address) ? [addr] : addr).each do |addr|
+            addr.ips.each do |net|
+              next unless family.is?.call(net)
+              network = Construqt::Addresses::Address.new
+              network.add_ip(net.to_string)
+              cfg = { 'network' => network }.merge(cfg)
+              cfg['prefix_length'] = [net.prefix,family.max_prefix] if addr_sub_prefix
+              @list << cfg
+            end
+          end
+
+          nil
+        end
+      end
+
+      def accept(cfg)
+        cfg = {}.merge(cfg)
+        cfg['rule'] = 'accept'
+        addr_v_(cfg)
+        @list << cfg if cfg['network']
+      end
+
+      def reject(cfg)
+        cfg = {}.merge(cfg)
+        cfg['rule'] = 'reject'
+        addr_v_(cfg)
+        @list << cfg if cfg['network']
+      end
+    end
+
+    class As < OpenStruct
+      def initialize(cfg)
+        super(cfg)
+      end
+
+      def name
+        (self.prefix || "AS") + self.as.to_s
+      end
+
+      def num
+        self.as
+      end
+    end
+
+    @as = {}
+    def self.add_as(as, config)
+      throw "as must be a number #{as}" unless as.kind_of?(Fixnum)
+      throw "as defined before #{as}" if @as[as]
+      config['as'] = as
+      @as[as] = As.new(config)
+    end
+
+    def self.find_as(as)
+      ret = @as[as]
+      throw "as not found #{as}" unless ret
+      ret
+    end
+
+    def self.add_filter(name, &block)
+      @filters[name] = Filter.new(name)
+      block.call(@filters[name])
+      @filters[name]
+    end
+
+    def self.filters
+      @filters.values
+    end
+
+    def self.find_filter(name)
+      ret = @filters[name]
+      throw "bgp not filter with name #{name}" unless ret
+      ret
+    end
+  end
+end

data/lib/construqt/cables.rb

@@ -0,0 +1,47 @@
+
+module Construqt
+
+  class Cables
+
+    def initialize(region)
+      @region = region
+      @cables = {}
+    end
+
+    def region
+      @region
+    end
+
+    class Cable
+      attr_reader :left, :right
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def key
+        [left.name, right.name].sort.join("<=>")
+      end
+    end
+
+    class DirectedCable
+      attr_accessor :cable, :other
+      def initialize(cable, other)
+        self.cable = cable
+        self.other = other
+      end
+    end
+
+    def add(iface_left, iface_right)
+      #    throw "left should be a iface #{iface_left.class.name}" unless iface_left.kind_of?(Construqt::Flavour::InterfaceDelegate)
+      #    throw "right should be a iface #{iface_right.class.name}" unless iface_right.kind_of?(Construqt::Flavour::InterfaceDelegate)
+      throw "left has a cable #{iface_left.cable}" if iface_left.cable
+      throw "right has a cable #{iface_right.cable}" if iface_right.cable
+      cable = Cable.new(iface_left, iface_right)
+      throw "cable exists #{iface_left.cable}=#{iface_right.cable}" if @cables[cable.key]
+      iface_left.cable = DirectedCable.new(cable, iface_right)
+      iface_right.cable = DirectedCable.new(cable, iface_left)
+      cable
+    end
+  end
+end

data/lib/construqt/firewalls.rb

@@ -0,0 +1,247 @@
+module Construqt
+  module Firewalls
+
+    @firewalls = {}
+    module Actions
+      NOTRACK = :NOTRACK
+      SNAT = :SNAT
+      ACCEPT = :ACCEPT
+      DROP = :DROP
+    end
+
+    class Firewall
+      def initialize(name)
+        @name = name
+        @raw = Raw.new(self)
+        @nat = Nat.new(self)
+        @forward = Forward.new(self)
+        @host = Host.new(self)
+      end
+
+      def name
+        @name
+      end
+
+      class Raw
+        attr_reader :firewall
+        def initialize(firewall)
+          @firewall = firewall
+          @rules = []
+        end
+
+        class RawEntry
+          include Util::Chainable
+          chainable_attr :prerouting, true, false, lambda{|i| @output = false; input_only(true); output_only(false) }
+          chainable_attr :input_only, true
+          chainable_attr :output, true, false, lambda {|i| @prerouting = false; input_only(false); output_only(true) }
+          chainable_attr :output_only, true
+          chainable_attr :interface
+          chainable_attr :from_interface, true, false
+          chainable_attr_value :from_net, nil
+          chainable_attr_value :to, nil
+          chainable_attr_value :to_net, nil
+          chainable_attr_value :action, nil
+
+          def initialize
+            @from_is = nil
+          end
+
+          def from_is_inbound?
+            @from_is == :inbound
+          end
+          def from_is_outbound?
+            @from_is == :outbound
+          end
+          def from_is(direction)
+            @from_is = direction
+          end
+        end
+
+        def add
+          entry = RawEntry.new
+          @rules << entry
+          entry
+        end
+
+
+        def rules
+          @rules
+        end
+      end
+
+      def get_raw
+        @raw
+      end
+
+      def raw(&block)
+        block.call(@raw)
+      end
+
+      class Nat
+        attr_reader :firewall, :rules
+        def initialize(firewall)
+          @firewall = firewall
+          @rules = []
+        end
+
+        class NatEntry
+          include Util::Chainable
+          chainable_attr :prerouting, true, false, lambda{|i| @postrouting = false; input_only(true); output_only(false) }
+          chainable_attr :input_only
+          chainable_attr :postrouting, true, false, lambda{|i| @prerouting = false; input_only(false); output_only(true) }
+          chainable_attr :output_only
+          chainable_attr :to_source
+          chainable_attr :interface
+          chainable_attr :from_interface, true, false
+          chainable_attr_value :from_net, nil
+          chainable_attr_value :to_net, nil
+          chainable_attr_value :action, nil
+        end
+
+        def add
+          entry = NatEntry.new
+          @rules << entry
+          entry
+        end
+      end
+
+      def get_nat
+        @nat
+      end
+
+      def nat(&block)
+        block.call(@nat)
+      end
+
+      class Mangle
+        @rules = []
+        class Tcpmss
+        end
+
+        def tcpmss
+          @rules << Tcpmss.new
+        end
+      end
+
+      def mangle(&block)
+        block.call(@mangle)
+      end
+
+      class Forward
+        attr_reader :firewall, :rules
+        def initialize(firewall)
+          @firewall = firewall
+          @rules = []
+        end
+
+        class ForwardEntry
+          include Util::Chainable
+          chainable_attr :interface
+          chainable_attr :connection
+          chainable_attr :input_only, true, true
+          chainable_attr :output_only, true, true
+          chainable_attr :from_interface, true, false
+          chainable_attr :connection
+          chainable_attr :tcp
+          chainable_attr :udp
+          chainable_attr_value :log, nil
+          chainable_attr_value :from_net, nil
+          chainable_attr_value :to_net, nil
+          chainable_attr_value :action, nil
+
+          def initialize
+            @from_is = nil
+          end
+
+          def from_is_inbound?
+            @from_is == :inbound
+          end
+          def from_is_outbound?
+            @from_is == :outbound
+          end
+          def from_is(direction)
+            @from_is = direction
+          end
+
+          def port(port)
+            @ports ||= []
+            @ports << port
+            self
+          end
+
+          def get_ports
+            @ports ||= []
+          end
+        end
+
+        def add
+          entry = ForwardEntry.new
+          #puts "ForwardEntry: #{@firewall.name} #{entry.input_only?} #{entry.output_only?}"
+          @rules << entry
+          entry
+        end
+      end
+
+      def get_forward
+        @forward
+      end
+
+      def forward(&block)
+        block.call(@forward)
+      end
+
+      class Host
+        attr_reader :firewall, :rules
+        def initialize(firewall)
+          @firewall = firewall
+          @rules = []
+        end
+
+        class HostEntry < Forward::ForwardEntry
+          include Util::Chainable
+          chainable_attr :from_host
+          chainable_attr :to_host
+        end
+
+        def add
+          entry = HostEntry.new
+          #puts "ForwardEntry: #{@firewall.name} #{entry.input_only?} #{entry.output_only?}"
+          @rules << entry
+          entry
+        end
+      end
+
+      def get_host
+        @host
+      end
+
+      def host(&block)
+        block.call(@host)
+      end
+
+      #    class Input
+      #      class All
+      #      end
+
+      #      @rules = []
+      #      def all(cfg)
+      #        @rules << All.new(cfg)
+      #      end
+
+      #    end
+    end
+
+    def self.add(name, &block)
+      throw "firewall with this name exists #{name}" if @firewalls[name]
+      fw = @firewalls[name] = Firewall.new(name)
+      block.call(fw)
+      fw
+    end
+
+    def self.find(name)
+      ret = @firewalls[name]
+      throw "firewall with this name #{name} not found" unless @firewalls[name]
+      ret
+    end
+  end
+end