porkadot 0.1.0

data/lib/porkadot/cmd/install/bootstrap.rb

@@ -0,0 +1,50 @@
+
+module Porkadot; module Cmd; module Install; module Bootstrap
+  class Cli < Porkadot::SubCommandBase
+    include Porkadot::Utils
+
+    def initialize(*arg)
+      super
+    end
+
+    default_task :all
+    desc "all", "Install all bootstrap components"
+    def all
+      invoke :node
+      invoke :kubernetes
+      invoke :cleanup
+    end
+
+    desc "node", "Install bootstrap node"
+    def node
+      logger.info "Installing bootstrap node"
+      bootstrap = Porkadot::Install::Bootstrap.new(self.config)
+      kubelets = Porkadot::Install::KubeletList.new(self.config)
+      kubelets.install hosts: [bootstrap.host]
+      bootstrap.install
+      ""
+    end
+
+    desc "kubernetes", "Install bootstrap kubernetes"
+    def kubernetes
+      logger.info "Installing bootstrap kubernetes"
+      bootstrap = Porkadot::Install::Bootstrap.new(self.config)
+      k8s = Porkadot::Install::Kubernetes.new(self.config)
+      k8s.install(bootstrap.host)
+      ""
+    end
+
+    desc "cleanup", "Cleanup bootstrap node"
+    def cleanup
+      logger.info "Cleanup bootstrap node"
+      bootstrap = Porkadot::Install::Bootstrap.new(self.config)
+      bootstrap.cleanup
+      ""
+    end
+
+    def self.subcommand_prefix
+      'install bootstrap'
+    end
+  end
+
+end; end; end; end

data/lib/porkadot/cmd/install.rb

@@ -0,0 +1,36 @@
+
+module Porkadot; module Cmd; module Install
+  class Cli < Porkadot::SubCommandBase
+    include Porkadot::Utils
+
+    default_task :all
+    desc "all", "Install Kubernetes cluster"
+    def all
+      invoke :kubelet, [], options
+      invoke :bootstrap, [], options
+    end
+
+    desc "kubelet", "Install kubelet to nodes"
+    option :node, type: :string
+    option :force, type: :boolean, default: false
+    def kubelet
+      logger.info "Installing kubelet"
+      kubelets = Porkadot::Install::KubeletList.new(self.config)
+      nodes = []
+      if node = options[:node]
+        nodes = kubelets[node]
+      else
+        nodes = kubelets.kubelets.values
+      end
+      kubelets.install hosts: nodes, force: options[:force]
+      ""
+    end
+
+    desc "bootstrap", "Install bootstrap components"
+    subcommand "bootstrap", Porkadot::Cmd::Install::Bootstrap::Cli
+
+    def self.subcommand_prefix
+      'install'
+    end
+  end
+end; end; end

data/lib/porkadot/cmd/render/certs.rb

@@ -0,0 +1,68 @@
+require 'forwardable'
+
+module Porkadot; module Cmd; module Render; module Certs
+  class Cli < Porkadot::SubCommandBase
+    include Porkadot::Utils
+
+    def initialize(*arg)
+      super
+    end
+
+    default_task :all
+    desc "all", "Render all certificates to deploy Kubernetes cluster"
+    def all
+      invoke :etcd
+      invoke :kubernetes
+    end
+
+    desc 'etcd', "Render certificates to deploy Etcd"
+    def etcd
+      logger.info "Generating etcd certificates"
+      certs = Porkadot::Assets::Certs.new(config).etcd
+      logger.info "--> CA key and certs"
+      certs.ca_key
+      certs.ca_cert(true)
+      logger.info "--> Client key and certs"
+      certs.client_key
+      certs.client_cert(true)
+      ''
+    end
+
+    desc 'kubernetes', "Render certificates to deploy Kubernetes"
+    def kubernetes
+      logger.info "Generating kubernetes certificates"
+      certs = Porkadot::Assets::Certs.new(config).kubernetes
+      logger.info "--> CA key and certs"
+      certs.ca_key
+      certs.ca_cert(true)
+      logger.info "--> API server key and certs"
+      certs.apiserver_key
+      certs.apiserver_cert(true)
+      logger.info "--> Kubelet client key and certs"
+      certs.kubelet_client_key
+      certs.kubelet_client_cert
+      # logger.info "--> Bootstrap client key and certs"
+      # bootstrap_client_key = self.private_key(self.assets.k8s_bootstrap_key_path)
+      # self.client_cert(self.assets.k8s_bootstrap_cert_path, '/O=porkadot:node-bootstrappers/CN=node-bootstrapper', bootstrap_client_key, ca_cert, ca_key)
+      logger.info "--> Admin client key and certs"
+      certs.client_key
+      certs.client_cert(true)
+      logger.info "--> Private key for signing service account tokens"
+      certs.sa_private_key
+      certs.sa_public_key
+
+      front_proxy_certs = Porkadot::Assets::Certs.new(config).front_proxy
+      logger.info "--> Front-proxy CA key and certs"
+      front_proxy_certs.ca_key
+      front_proxy_certs.ca_cert(true)
+      logger.info "--> Front-proxy client key and certs"
+      front_proxy_certs.client_key
+      front_proxy_certs.client_cert(true)
+      ''
+    end
+
+    def self.subcommand_prefix
+      'render certs'
+    end
+  end
+end; end; end; end

data/lib/porkadot/cmd/render.rb

@@ -0,0 +1,67 @@
+
+module Porkadot; module Cmd; module Render
+  class Cli < Porkadot::SubCommandBase
+    include Porkadot::Utils
+
+    default_task :all
+    desc "all", "Render all assets to deploy Kubernetes cluster"
+    def all
+      invoke "porkadot:cmd:render:certs:cli:all", [], options
+      invoke :kubelet, [], options
+      invoke :etcd, [], options
+      invoke :bootstrap, [], options
+      invoke :kubernetes, [], options
+    end
+
+    desc "certs", "Render certificates to deploy Kubernetes"
+    subcommand "certs", Porkadot::Cmd::Render::Certs::Cli
+
+    desc "kubelet", "Render kubelet related files"
+    option :node, type: :string
+    def kubelet
+      logger.info "Generating kubelet related files"
+      kubelets = Porkadot::Assets::KubeletList.new(self.config)
+      if node = options[:node]
+        kubelets[node].render
+      else
+        kubelets.render
+      end
+      ""
+    end
+
+    desc "etcd", "Render etcd related files"
+    option :node, type: :string
+    def etcd
+      logger.info "Generating etcd related files"
+      etcds = Porkadot::Assets::EtcdList.new(self.config)
+      if node = options[:node]
+        etcds[node].render
+      else
+        etcds.render
+      end
+      ""
+    end
+
+    desc "bootstrap", "Render bootstrap related files"
+    def bootstrap
+      logger.info "Generating bootstrap related files"
+      bootstrap = Porkadot::Assets::Bootstrap.new(self.config)
+      kubelet = Porkadot::Assets::Kubelet.new(self.config.bootstrap.kubelet_config)
+      kubelet.render
+      bootstrap.render
+      ""
+    end
+
+    desc "kubernetes", "Render kubernetes manifests"
+    def kubernetes
+      logger.info "Generating kubernetes manifests"
+      k8s = Porkadot::Assets::Kubernetes.new(self.config)
+      k8s.render
+      ""
+    end
+
+    def self.subcommand_prefix
+      'render'
+    end
+  end
+end; end; end

data/lib/porkadot/cmd.rb

@@ -0,0 +1,4 @@
+module Porkadot::Cmd
+end
+
+require 'porkadot/cmd/cli'

data/lib/porkadot/config.rb

@@ -0,0 +1,115 @@
+require 'yaml'
+require 'hashie'
+require 'logger'
+
+module Porkadot
+  class Raw < ::Hashie::Mash
+    disable_warnings :keys, :min
+  end
+
+  class Config
+    attr_reader :raw
+    attr_reader :logger
+
+    def initialize path
+      default_config = {}
+      open(File.expand_path(File.join(Porkadot::ROOT, 'porkadot', 'default.yaml'))) do |io|
+        default_config = YAML::load(io)
+      end
+      open(File.expand_path(path)) do |io|
+        @raw = ::Porkadot::Raw.new(default_config.rmerge(YAML.load(io)))
+      end
+      @logger = Logger.new(STDOUT)
+    end
+
+    def certs
+      @certs ||= Porkadot::Configs::Certs.new(self)
+      return @certs
+    end
+
+    def connection
+      self.raw.connection
+    end
+
+    def lb
+      @lb ||= Porkadot::Configs::Lb.new(self)
+      return @lb
+    end
+
+    def cni
+      @cni ||= Porkadot::Configs::Cni.new(self)
+      return @cni
+    end
+
+    def bootstrap
+      @bootstrap ||= Porkadot::Configs::Bootstrap.new(self)
+      return @bootstrap
+    end
+
+    def kubernetes
+      @kubernetes ||= Porkadot::Configs::Kubernetes.new(self)
+      return @kubernetes
+    end
+    alias k8s kubernetes
+
+    def etcd
+      @etcd ||= Porkadot::Configs::Etcd.new(self)
+      return @etcd
+    end
+
+    def nodes
+      @nodes ||= {}.tap do |nodes|
+        self.raw.nodes.each do |k, v|
+          nodes[k] = Porkadot::Configs::Kubelet.new(self, k, v)
+        end
+      end
+      return @nodes
+    end
+
+    def etcd_nodes
+      @etcd_nodes ||= {}.tap do |nodes|
+        self.raw.nodes.each do |k, v|
+          if v && v.labels && v.labels.to_hash.keys.include?(Porkadot::ETCD_MEMBER_LABEL)
+            nodes[k] = Porkadot::Configs::EtcdNode.new(self, k, v)
+          end
+        end
+      end
+      return @etcd_nodes
+    end
+
+    def assets_dir
+      File.expand_path(raw.local.assets_dir)
+    end
+
+  end
+
+  module ConfigUtils
+
+    def config
+      return @config
+    end
+
+    def logger
+      return @config.logger
+    end
+
+    def raw
+      return @raw
+    end
+
+    def asset_path file
+      File.join(self.target_path, file.to_s)
+    end
+    alias path asset_path
+
+    def method_missing name, *args
+      return nil if self.raw.nil?
+      self.raw[name]
+    end
+
+    def respond_to_missing? sym, include_private
+      return false if self.raw.nil?
+      self.raw.respond_to_missing?(sym, include_private) ? true : super
+    end
+  end
+end

data/lib/porkadot/configs/bootstrap.rb

@@ -0,0 +1,67 @@
+
+module Porkadot; module Configs
+  class Bootstrap
+    class Kubelet < Porkadot::Configs::Kubelet
+      attr_reader :bootstrap_config
+      def initialize bootstrap_config
+        @bootstrap_config = bootstrap_config
+        # TODO: specify default node
+        super bootstrap_config.config, 'bootstrap', bootstrap_config.raw.node
+      end
+
+      def control_plane_endpoint
+        "127.0.0.1:#{bootstrap_config.config.k8s.apiserver.bind_port}"
+      end
+
+      def target_path
+        File.join(bootstrap_config.target_path, 'kubelet')
+      end
+    end
+
+    include Porkadot::ConfigUtils
+    attr_reader :kubelet_config
+
+    def initialize config
+      @config = config
+      @raw = config.raw.bootstrap
+      @kubelet_config = Kubelet.new(self)
+    end
+
+    def target_path
+      File.join(self.config.assets_dir, 'bootstrap')
+    end
+
+    def bootstrap_path
+      File.join(self.target_path, 'bootstrap')
+    end
+
+    def secrets_path
+      File.join(self.bootstrap_path, 'secrets')
+    end
+
+    def kubeconfig_path
+      File.join(self.bootstrap_path, 'kubeconfig-bootstrap.yaml')
+    end
+
+    def manifests_path
+      File.join(self.target_path, 'manifests')
+    end
+
+    def apiserver_path
+      File.join(self.manifests_path, 'kube-apiserver.bootstrap.yaml')
+    end
+
+    def controller_manager_path
+      File.join(self.manifests_path, 'kube-controller-manager.bootstrap.yaml')
+    end
+
+    def scheduler_path
+      File.join(self.manifests_path, 'kube-scheduler.bootstrap.yaml')
+    end
+
+    def install_sh_path
+      File.join(self.target_path, 'install.sh')
+    end
+  end
+
+end; end

data/lib/porkadot/configs/certs/etcd.rb

@@ -0,0 +1,33 @@
+
+module Porkadot; module Configs; class Certs
+  class Etcd
+    include Porkadot::Configs::CertsUtils
+    attr_reader :config
+    attr_reader :logger
+
+    def initialize config
+      @config = config
+      @logger = config.logger
+    end
+
+    def target_dir
+      File.join(self.certs_root_dir, 'etcd')
+    end
+
+    def ca_key_path
+      File.join(self.target_dir, 'ca.key')
+    end
+
+    def ca_cert_path
+      File.join(self.target_dir, 'ca.crt')
+    end
+
+    def client_key_path
+      File.join(self.target_dir, 'etcd-client.key')
+    end
+
+    def client_cert_path
+      File.join(self.target_dir, 'etcd-client.crt')
+    end
+  end
+end; end; end

data/lib/porkadot/configs/certs/front_proxy.rb

@@ -0,0 +1,33 @@
+
+module Porkadot; module Configs; class Certs
+  class FrontProxy
+    include Porkadot::Configs::CertsUtils
+    attr_reader :config
+    attr_reader :logger
+
+    def initialize config
+      @config = config
+      @logger = config.logger
+    end
+
+    def target_dir
+      File.join(self.certs_root_dir, 'kubernetes')
+    end
+
+    def ca_key_path
+      File.join(self.target_dir, 'front-proxy-ca.key')
+    end
+
+    def ca_cert_path
+      File.join(self.target_dir, 'front-proxy-ca.crt')
+    end
+
+    def client_key_path
+      File.join(self.target_dir, 'front-proxy-client.key')
+    end
+
+    def client_cert_path
+      File.join(self.target_dir, 'front-proxy-client.crt')
+    end
+  end
+end; end; end

data/lib/porkadot/configs/certs/k8s.rb

@@ -0,0 +1,89 @@
+
+module Porkadot; module Configs; class Certs
+  class Kubernetes
+    include Porkadot::Configs::CertsUtils
+    attr_reader :config
+    attr_reader :logger
+
+    def initialize config
+      @config = config
+      @logger = config.logger
+    end
+
+    def additional_sans
+      dns_names = []
+      ips = []
+      if self.config.k8s.control_plane_endpoint
+        host = self.config.k8s.control_plane_endpoint.split(':')[0]
+        self.ipaddr?(host) ? ips << host : dns_names << host
+      end
+      self.config.nodes.each do |_, node|
+        k = node.name
+        v = node
+        next unless v.labels && v.labels.include?(Porkadot::K8S_MASTER_LABEL)
+        self.ipaddr?(k) ? ips << k : dns_names << k
+        if v.hostname
+          self.ipaddr?(v.hostname) ? ips << v.hostname : dns_names << v.hostname
+        end
+      end
+
+      sans = dns_names.map {|v| "DNS:#{v}"} + ips.map {|v| "IP:#{v}"}
+      default_sans = %W(
+        DNS:kubernetes
+        DNS:kubernetes.default
+        DNS:kubernetes.default.svc
+        DNS:kubernetes.default.svc.#{self.config.k8s.networking.dns_domain}
+        DNS:localhost
+        IP:#{self.config.k8s.networking.kubernetes_ip}
+        IP:127.0.0.1
+      )
+      return default_sans + sans.uniq
+    end
+
+    def target_dir
+      File.join(self.certs_root_dir, 'kubernetes')
+    end
+
+    def ca_key_path
+      File.join(self.target_dir, 'ca.key')
+    end
+
+    def ca_cert_path
+      File.join(self.target_dir, 'ca.crt')
+    end
+
+    def apiserver_key_path
+      File.join(self.target_dir, 'apiserver.key')
+    end
+
+    def apiserver_cert_path
+      File.join(self.target_dir, 'apiserver.crt')
+    end
+
+    def kubelet_client_key_path
+      File.join(self.target_dir, 'kubelet-client.key')
+    end
+
+    def kubelet_client_cert_path
+      File.join(self.target_dir, 'kubelet-client.crt')
+    end
+
+    def admin_key_path
+      File.join(self.target_dir, 'admin.key')
+    end
+    alias_method :client_key_path, :admin_key_path
+
+    def admin_cert_path
+      File.join(self.target_dir, 'admin.crt')
+    end
+    alias_method :client_cert_path, :admin_cert_path
+
+    def sa_private_key_path
+      File.join(self.target_dir, 'sa.key')
+    end
+
+    def sa_public_key_path
+      File.join(self.target_dir, 'sa.pub')
+    end
+  end
+end; end; end

data/lib/porkadot/configs/certs.rb

@@ -0,0 +1,50 @@
+require 'ipaddr'
+
+module Porkadot; module Configs
+
+  module CertsUtils
+
+    def certs_root_dir
+      File.join(self.config.assets_dir, 'certs')
+    end
+
+    def ipaddr?(addr)
+      IPAddr.new(addr)
+      return true
+    rescue IPAddr::InvalidAddressError
+      return false
+    end
+
+  end
+
+  class Certs
+    include CertsUtils
+    attr_reader :config
+    attr_reader :logger
+
+    def initialize config
+      @config = config
+      @logger = config.logger
+    end
+
+    def etcd
+      @etcd ||= ::Porkadot::Configs::Certs::Etcd.new(config)
+      return @etcd
+    end
+
+    def kubernetes
+      @kubernetes ||= ::Porkadot::Configs::Certs::Kubernetes.new(config)
+      return @kubernetes
+    end
+
+    def front_proxy
+      @front_proxy ||= ::Porkadot::Configs::Certs::FrontProxy.new(config)
+      return @front_proxy
+    end
+  end
+
+end; end
+
+require 'porkadot/configs/certs/etcd'
+require 'porkadot/configs/certs/k8s'
+require 'porkadot/configs/certs/front_proxy'

data/lib/porkadot/configs/cni.rb

@@ -0,0 +1,22 @@
+
+module Porkadot; module Configs
+  class Cni
+    include Porkadot::ConfigUtils
+    attr_reader :type
+
+    def initialize config
+      @config = config
+      @type = config.raw.cni.type
+      @raw = config.raw.cni.send(config.raw.cni.type.to_sym)
+    end
+
+    def target_path
+      File.join(self.config.assets_dir, 'kubernetes')
+    end
+
+    def manifests_path
+      File.join(self.target_path, 'manifests')
+    end
+
+  end
+end; end