kproj

#!/usr/bin/env ruby
# -*-Ruby-*-

require 'json'
require 'tempfile'
require 'bundler/inline'
require 'yaml'

gemfile do
  source 'https://rubygems.org'
  gem "toml", "~> 0.3.0"
  gem "highline", "2.0.3"
  gem "thor"
end

class Kubectl
  def self.contexts
    JSON.parse( `kubectl config view -o json` )["contexts"].collect{ |x| x['name'] }
  end

  def self.context
    `kubectl config current-context --skip-headers=true`.chomp
  end

  def self.knative_operator
    return deployment_status( 'knative-operator', 'operator.knative.dev/release' )
  end

  def self.knative_serving
    return crd_status( 'knative-serving', 'knativeservings.operator.knative.dev', 'operator.knative.dev/release' )
  end

  def self.knative_eventing
    return crd_status( 'knative-eventing', 'knativeeventings.operator.knative.dev', 'operator.knative.dev/release' )
  end

  def self.cert_manager
    return deployment_status 'cert-manager -n cert-manager', 'helm.sh/chart'
  end

  def self.postgres
    return stateful_set_status 'postgres-postgresql', 'helm.sh/chart'
  end

  def self.deployment_status deployment, version_label
    data = YAML.load( `kubectl get deployment #{deployment} -o yaml` )

    return {defined:false, name: deployment} if !data

    results = {
      defined: true,
      name: data['metadata']['name'],
      readyReplicas: data['status']['readyReplicas'],
      version: data['metadata']['labels'][version_label]
    }
  end

  def self.stateful_set_status deployment, version_label
    data = YAML.load( `kubectl get statefulsets #{deployment} -o yaml` )

    return {defined:false, name: deployment} if !data

    results = {
      defined: true,
      name: data['metadata']['name'],
      readyReplicas: data['status']['readyReplicas'],
      version: data['metadata']['labels'][version_label]
    }
  end

  def self.crd_status crd, crd_key, version_label
    data = YAML.load( `kubectl get crd #{crd_key} -o yaml` )

    return {defined:false, name: crd} if !data

    results = {
      defined: true,
      name: crd,
      readyReplicas: data['status']['conditions'].collect { |x| "#{x['reason']}: #{x['status']}" }.join( ", " ),
      version: data['metadata']['labels'][version_label]
    }
  end
end
  
class Config
  FILE="deployment.toml"

  def self.[](key)
    config[key]
  end

  def self.[]=(key, value)
    config[key] = value
  end

  def self.cli
    @cli ||= HighLine.new
  end
  
  def self.config
    begin
      @config ||= TOML::Parser.new(File.read(FILE)).parsed
      
      return @config
    rescue Errno::ENOENT
      puts "Couldn't find file #{FILE}"
      
      if cli.ask( "Create? " ) == 'y'
        return self.global_config
      end
      
      exit 1
    end
  end

  def self.write
    File.open(FILE, "w") { |file| file.write TOML::Generator.new(@config).body }
  end

  def self.global_config
    # Set kubectl context

    @config ||= {}
    @config["global"] ||= {}

    @config["global"]["context"] = @cli.choose do |menu|
      menu.prompt = "kubectl context we should use:  "
      Kubectl.contexts.each { |c| menu.choice(c) }
      menu.default = @config["global"]["context"] ||= Kubectl.context
    end

    @config["global"]["image_prefix"] = @cli.ask("Image name template prefix: ") do |q|
      q.default = @config["global"]["image_prefix"] || "#{ENV['USER']}/"
    end

    @config["global"]["domain"] = @cli.ask("Domain: " ) do |q|
      q.default = @config["global"]["domain"] if @config["global"]["domain"]
    end


    if @cli.ask( "Save? y/n" ) == 'y'
      write
      return @config
    end

    puts "Not saving"
    exit 1
  end
end

class Database
  def self.list
    `kubectl get svc |grep -v None| awk '/postgres/ {print $1}'`.split( /\n/ )
  end

  def self.choose_database
    choices = list

    if choices.length == 0
      puts "No databases found"
      exit 1
    end
    
    if list.length == 1
      return list.first
    end
    
    HighLine.choose do |menu|
      menu.prompt = "Select a database: "
      choices.each { |c| menu.choice(c) }
      menu.default = choices.first
    end
  end
  
  def self.password( name )
    `kubectl get secret --namespace default #{name} -o jsonpath="{.data.postgresql-password}" | base64 --decode`
  end

  def self.remote_url( name, schema )
      "postgresql://postgres:#{password(name)}@#{name}.default.svc.cluster.local:5432/#{schema}?schema=public"
  end

  def self.config_map( name, schema )
    config_map = "#{name}-#{schema}"

    if !system( "kubectl get configmap #{config_map} > /dev/null" )
      puts "Creating config map"

      t = Tempfile.create do |f|
        f.puts "DATABASE_URL=#{remote_url( name, schema )}"
        f.close

        if !system( "kubectl create configmap #{config_map} --from-env-file=#{f.path}")
          puts "Problem creating config map!"
          exit 1
        end
      end
    end

    Config['databases'] ||= {}
    Config['databases'][schema] ||= {}
    Config['databases'][schema]['config_map'] = config_map
    Config.write

    config_map
  end

  def self.update( service )
    return if !Config[service]
    schema = Config[service]['schema']

    if !schema
      puts "#{service}: no schema found"

      # TODO remove configmap if exists on the service
    else
      puts "#{service}: getting database config map"
      
      Config['databases'] ||= {}
      c = Config['databases']
    
      c[schema] ||= {}

      # Create the schema if defined
      c[schema]['database'] ||= Database.choose_database
      c[schema]['config_map'] ||= Database.config_map( c[schema]['database'], schema )

      Config[service]['config_maps'] ||= []
      Config[service]['config_maps'] << c[schema]['config_map'] 
      Config[service]['config_maps'].uniq!
      Config.write

      migrate( service )
    end
  end

  def self.database_forwarder( service, schema )
    schema = Config[service]['schema']
    database = Config['databases'][schema]['database']

    puts "#{database}: Looking up password"
    password = `kubectl get secret --namespace default #{database} -o jsonpath="{.data.postgresql-password}" | base64 --decode`

    localurl = "postgresql://postgres:#{password}@localhost:5433/#{schema}?schema=public"
    remoteurl = "postgresql://postgres:#{password}@#{database}.default.svc.cluster.local:5432/#{schema}?schema=public"

    puts "#{database}: Starting port forwarder..."
    pid = spawn( "kubectl port-forward svc/#{database} 5433:5432" )
    
    puts "#{database}: Waiting 1 second"
    sleep 1

    sub = fork do
      Dir.chdir(service)

      yield localurl, remoteurl
    end

    Process.wait sub
    Process.kill "TERM", pid

    puts "#{database}: Waiting for port forwarder to stop"
    Process.wait pid    
  end

  def self.migrate( service )
    if Config[service]['schema']
      database_forwarder( service, Config[service]['schema'] ) do |local, remote|
        cmd = Config[service]['migrate'] || "npx prisma migrate deploy"
        puts "#{service}: Running #{cmd}"
        migrate = spawn( { "DATABASE_URL" => local }, cmd )
        Process.wait migrate
      end
    else
      puts "#{service}: No schema defined"
    end
  end
end

class Service
  def self.cli; @cli ||= HighLine.new; end
  
  def self.build name

    if !File.exists? "#{name}/Dockerfile"
      puts "#{name}/Dockerfile not found"
      exit 1
    end

    image = image_name name

    if !system( "docker build #{name} -t #{image} --platform linux/amd64 && docker push #{image}" )
      puts "Problem building, aborting"
      exit 1
    end
  end

  def self.image_name( name )
    if( !Config[name] )
      puts "#{name} not found"
    end

    if( !(Config[name] && Config[name]['image']) )
      Config[name] ||= {}
      Config[name]['image'] = cli.ask "Image name? " do |q|
        q.default = "#{Config['global']['image_prefix']}#{name}"
      end

      Config.write
    end

    Config[name]['image']
  end

  def self.service_name( name )
    if( !Config[name] )
      puts "#{name} not found"
    end

    Config[name] ||= {}

    if( !Config[name]['service'] )
      Config[name]['service'] = cli.ask( "Deploy service under what name? ") do |q|
        q.default = name
      end
      Config.write
    end

    Config[name]['service']
  end

  def self.update( name )
    service = service_name name
    image = image_name name

    c = Config[name]

    if( c['service_type'] == 'job' )
      job_update( name )
      return
    end

    current_instance = ServiceInstance.new( name )

    cmd = current_instance.exists? ? 'update' : 'create'

    cmd_array = [ 'kn', 'service', cmd, service, '--image', image ]

    cm_add = (c['config_maps'] || [])- current_instance.config_maps
    cm_delete = current_instance.config_maps - (c['config_maps'] || [])

    cm_add.each do |config_map|
      puts "#{service} Adding cm:#{config_map}"
      cmd_array << '--env-from'
      cmd_array << "cm:#{config_map}"
    end

    cm_delete.each do |config_map|
      puts "#{service} Removing cm:#{config_map}"
      cmd_array << '--env-from'
      cmd_array << "cm:#{config_map}-"
    end

    puts "\nRunning #{cmd_array.join( ' ' )}"
    system( cmd_array.join( ' ' ) )
  end

  def self.job_update( name )
    file = "kubernetes/#{name}.yaml"
    
    puts "Creating backup job in #{file}"

    job = {
      apiVersion: "batch/v1",
      kind: "CronJob",
      metadata: {
        name: "postgres-backup"
      },
      spec: {
        schedule: "@daily",
        jobTemplate: { 
          spec: {
            template: {
              spec: {
                containers: [
                  {
                    name: "backup",
                    image: "wschenk/backup",
                    imagePullPolicy: "Always"
                  }],
                restartPolicy: "Never"
              }
            }
          }
        }
      }
    }

    spec = job[:spec][:jobTemplate][:spec][:template][:spec][:containers].first

    spec['envFrom'] ||= []
    spec['envFrom'] << {
      configMapRef: {
        name: "s3-access"
      }
    }

    Config['databases'].keys.each do |schema|
      puts schema
      spec['env'] ||= []
      spec['env'] << {
        name: "#{schema.upcase}_DATABASE_URL",
        valueFrom: {
          configMapKeyRef: {
            name: Config['databases'][schema]['config_map'],
            key: "DATABASE_URL"
          }
        }
      }
    end
      
    
    File.open( file, "w" ) do |out|
      out.write( YAML.dump( job ).gsub( /^(\s*):/, '\1' ).gsub( /(- ):/, '\1')  )
    end

    system( "kubectl apply -f #{file}" )
  end
end

class ServiceInstance
  def initialize( service )
    @exists = false
    info = `kn service describe #{service} -o yaml`
    if info != ""
      puts "#{service}: Found deployed service"
      @exists = true
      @info = YAML.load( info )
    else
      puts "Does not exist"
    end
  end

  def exists?; @exists; end
  def name; @exists && @info["metadata"]["name"]; end
  def generation; @exists &&  @info["metadata"]["generation"]; end
  def created; @exists && @info["metadata"]["creationTimestamp"]; end
  def containers; @exists && @info["spec"]["template"]["spec"]["containers"]; end
  def container; @exists && containers.first; end
  def env; @exists && container["env"] || []; end
  def config_maps
    return [] if !exists?
    (container['envFrom'] || []).select do |x|
      x["configMapRef"]
    end.collect do |x|
      x["configMapRef"]["name"]
    end
  end
  def has_sink?; @exists && env.select { |x| x["name"] == 'K_SINK' }.length > 0; end
  def image; @exists && container["image"]; end
  def address; @exists && @info['status']['address']['url']; end
  def url; @exists && @info['status']['url']; end

  def display
    fmt = "%20s = %s\n"

    if !exists?
      puts "No service found"
    else
      [
        ["Name", name],
        ["Generation", generation],
        ["Created at", created],
        ["Image", image],
        ["Address", address],
        ["URL", url],
        ["Has Sink?", has_sink?],
        ["Config Maps", config_maps.join( " " )]
      ].each do |e|
        printf fmt, e[0], e[1]
      end

      env.each do |env|
        printf fmt, env["name"], env["value"]
      end
    end
  end
end

class Eventing
  def self.create_source( service )
    puts "#{service}: Creating #{service}-binding"
    system( "kn source binding create #{service}-binding --subject Service:serving.knative.dev/v1:#{service} --sink broker:default" )
  end

  def self.delete_source( service )
    puts "#{service}: Deleting #{service}-binding"
    system( "kn source binding delete #{service}-binding" )
  end

  def self.triggers( service = nil )
    json_string = `kn triggers ls -o json`
    if $?.exitstatus
      JSON.parse( json_string )["items"].collect do |x|
        {
          "name": x["metadata"]["name"],
          "filter": x["spec"]["filter"]["attributes"]["type"],
          "service": x["spec"]["subscriber"]["ref"]["name"]
        }
      end.select do |e|
        service ? (e[:service] == service) : true
      end
    else
      {}
    end
  end

  def self.trigger_name( service, event )
    "#{service}-#{event}".gsub( /\./, "-" )
  end
  
  def self.create_trigger( service, event )
    puts "#{service}: Creating #{trigger_name( service, event )}"
    system( "kn trigger create #{trigger_name( service, event )} --broker default --filter type=#{event} --sink #{service}" )
  end

  def self.delete_trigger( name )
    puts "#{service}: Deleting #{trigger_name( service, event )}"
    system( "kn trigger delete #{name}" )
  end

  def self.update( name )
    current_instance = ServiceInstance.new( name )

    if( !current_instance.exists? )
      puts "Eventing.update: Unable to find deployed event #{name}"
    end

    c = Config[name]

    if c["binding"] && !current_instance.has_sink?
      Eventing.create_source( name )
    elsif !c['binding'] && current_instance.has_sink?
      Eventing.delete_source( name )
    end

    configured_events = c["events"] || []
    existing_triggers = triggers( name )
    existing_events = existing_triggers.collect { |x| x[:filter] }

    (configured_events - existing_events).each do |event|
      create_trigger( name, event )
    end

    (existing_events - configured_events).each do |event|
      trigger_name = existing_triggers.select do |x|
        x[:filter] == event
      end.first[:name]

      delete_trigger( trigger_name )
    end
  end
end


class DatabaseCLI < Thor
  desc "dbs", "List databases"
  def dbs
    Database.list.each do |db|
      puts db
    end
  end

  desc "schemas", "List defined schemas"
  def schemas
    Config['databases'].each do |d|
      p d
    end
  end

  desc "password", "get the password of a database"
  def password( reference )
    puts "Password is #{Database.password(reference)}"
  end

  desc "migrate name", "runs the db migration"
  def migrate( service )
    Database.migrate( service )
  end

  desc "database_url db schema", "set the database secret"
  def database_url( db, schema )
    puts Database.config_map( db, schema )
  end

  desc "job", "Create the backup job"
  def job
    Database.backup_job
  end
end

class CLI < Thor
  desc "doctor", "Sync the state of the cluster"
  def doctor
    fmt = "%-20s %-20s %s\n"

    printf fmt, "NAME", "VERSION", "READY REPLICAS"

    [ Kubectl.knative_operator,
      Kubectl.knative_serving,
      Kubectl.knative_eventing,
      Kubectl.cert_manager,
      Kubectl.postgres
    ].each do |status|
      printf fmt, status[:name], status[:version], status[:readyReplicas]
    end
  end

  desc "build", "Builds a service"
  def build( name )
    Service.build name 
  end

  desc "update", "Pushes configuration to server"
  def update( name )
    Database.update( name )
    Service.update( name )
    Eventing.update( name )
  end

  desc "up name", "Deploys a service"
  option :nobuild
  def up( name )
    Service.build( name ) unless options[:nobuild]
    update( name )
  end
  
  desc "info name", "queries the cluster"
  def info( name )
    ServiceInstance.new( name ).display
  end

  desc "trigger_add name event", "add a trigger to the service"
  def trigger_add( name, event )
    info = ServiceInstance.new(name)

    if !info.exists?
      puts "#{name} not found"
      exit 1
    end

    c = Config[name]

    p c

    c["binding"] = true
    c["events"] ||= []
    c["events"] << event
    c["events"].uniq!

    Config.write
    Eventing.update( name )
  end
  
  desc "db", "Database functions"
  subcommand "db", DatabaseCLI
end

CLI.start(ARGV)