rhea 0.0.1 → 0.1.0

data/lib/rhea/kubernetes/commands/reschedule.rb

@@ -0,0 +1,21 @@
+module Rhea
+  module Kubernetes
+    module Commands
+      class Reschedule < Base
+        attr_accessor :command
+
+        def initialize(command_attributes)
+          self.command = Command.new(command_attributes)
+        end
+
+        def perform
+          command_attributes = command.attributes.slice(:image, :expression)
+          controller = Get.new(command_attributes).perform
+          process_count = controller.process_count
+          Scale.new(command_attributes.merge(process_count: 0)).perform
+          Scale.new(command_attributes.merge(process_count: process_count)).perform
+        end
+      end
+    end
+  end
+end

data/lib/rhea/kubernetes/commands/scale.rb

@@ -0,0 +1,108 @@
+module Rhea
+  module Kubernetes
+    module Commands
+      class Scale < Base
+        attr_accessor :command
+
+        def initialize(command_attributes)
+          self.command = Command.new(command_attributes)
+        end
+
+        def perform
+          if is_replication_controller_running?
+            scale_replication_controller
+          else
+            start_replication_controller
+          end
+        end
+
+        private
+
+        def is_replication_controller_running?
+          api.get_replication_controllers(label_selector: "name=#{command.key}").length > 0
+        end
+
+        def start_replication_controller
+          parsed_command_expression = parse_command_expression
+          raw_command_expression = parsed_command_expression[:raw_command_expression]
+          env_vars = parsed_command_expression[:env_vars]
+          formatted_env_vars = format_env_vars(env_vars)
+
+          container_config = {
+            'name' => command.key,
+            'image' => command.image,
+            'env' => formatted_env_vars,
+            'command' => raw_command_expression.split(/\s+/)
+          }.merge(Rhea.configuration.container_options)
+
+          controller = Kubeclient::ReplicationController.new
+          controller.metadata = {
+            'name' => command.key,
+            'namespace' => NAMESPACE,
+            'labels' => {
+              'name' => command.key
+            },
+            'annotations' => {
+              'rhea_command' => command.expression
+            }
+          }
+          controller.spec = {
+            'replicas' => command.process_count,
+            'selector' => {
+              'name' => command.key
+            },
+            'template' => {
+              'metadata' => {
+                'labels' => {
+                  'name' => command.key
+                },
+                'annotations' => {
+                  'rhea_command' => command.expression
+                }
+              },
+              'spec' => {
+                'containers' => [container_config]
+              }
+            }
+          }
+
+          api.create_replication_controller(controller)
+        end
+
+        def scale_replication_controller
+          controller = api.get_replication_controllers(label_selector: "name=#{command.key}").first
+          controller.spec.replicas = command.process_count
+          api.update_replication_controller(controller)
+        end
+
+        def parse_command_expression
+          match = command.expression.match(/((?:[A-Z]+=[^\s]+\s+)+)?(.*)/)
+          env_vars_string = match[1]
+          raw_command_expression = match[2]
+          env_vars = {}
+          if env_vars_string.present?
+            env_vars_strings = env_vars_string.strip.split(/\s+/)
+            env_vars_strings.each do |string|
+              name, value = string.split('=')
+              env_vars[name] = value
+            end
+          end
+          {
+            raw_command_expression: raw_command_expression,
+            env_vars: env_vars
+          }
+        end
+
+        def format_env_vars(env_vars)
+          hash = env_vars.merge(Rhea.configuration.env_vars)
+          hash.map do |name, value|
+            {
+              'name' => name,
+              'value' => value
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhea/kubernetes/configuration.rb

@@ -0,0 +1,30 @@
+module Rhea
+  class Configuration
+    attr_accessor :command_types, :container_options, :default_command_type_key, :default_image, :env_vars, :kube_api
+
+    def initialize
+      self.command_types = [
+        {
+          key: 'default',
+          name: 'Default',
+          format: '$INPUT'
+        },
+        {
+          key: 'resque',
+          name: 'Resque',
+          format: 'QUEUES=$INPUT rake resque:work'
+        },
+        {
+          key: 'sidekiq',
+          name: 'Sidekiq',
+          format: 'bundle exec sidekiq $INPUT'
+        }
+      ]
+      self.container_options = {}
+      self.default_command_type_key = 'default'
+      self.default_image = nil
+      self.env_vars = {}
+      self.kube_api = {}
+    end
+  end
+end

data/lib/rhea/kubernetes/events/recent.rb

@@ -0,0 +1,23 @@
+module Rhea
+  module Kubernetes
+    module Events
+      class Recent
+        def perform
+          api = Rhea::Kubernetes::Api.new
+          events = api.get_events
+          events.map! do |event|
+            OpenStruct.new(
+              hostname: event.source.host,
+              message: event.message,
+              type: event.reason,
+              resource_type: event.involvedObject.kind,
+              resource_id: event.involvedObject.name,
+              created_at: Time.parse(event.lastTimestamp)
+            )
+          end
+          events.sort_by(&:created_at).reverse
+        end
+      end
+    end
+  end
+end

data/lib/rhea/kubernetes/nodes/all.rb

@@ -0,0 +1,45 @@
+module Rhea
+  module Kubernetes
+    module Nodes
+      class All
+        def perform
+          api = Rhea::Kubernetes::Api.new
+          pods = api.get_pods
+          hostnames_nodes = {}
+          pods.each do |pod|
+            command_expression = pod.metadata.annotations.rhea_command
+            next if command_expression.nil?
+            hostname = pod.spec.nodeName
+            hostnames_nodes[hostname] ||= {}
+            hostnames_nodes[hostname][:image] = pod[:table][:spec][:containers][0]['image']
+
+            started_at = pod.status.startTime
+            if started_at
+              started_at = Time.parse(started_at)
+              last_started_at = hostnames_nodes[hostname][:last_started_at]
+              if last_started_at.nil? || started_at > last_started_at
+                hostnames_nodes[hostname][:last_started_at] = started_at
+              end
+            end
+
+            phase = pod.status.phase
+            containers = pod.spec.containers
+            containers.each do |container|
+              image = container.image
+              command = Command.new(
+                expression: command_expression,
+                image: image
+              )
+              hostnames_nodes[hostname][:commands_phases] ||= {}
+              hostnames_nodes[hostname][:commands_phases][command] ||= []
+              hostnames_nodes[hostname][:commands_phases][command] << phase
+            end
+          end
+          hostnames_nodes.map do |hostname, node|
+            OpenStruct.new(node.merge(hostname: hostname))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rhea/kubernetes/system_services.rb

@@ -0,0 +1,22 @@
+module Rhea
+  module Kubernetes
+    module SystemServices
+      module_function
+
+      def service_names_urls
+        @service_names_urls ||= begin
+          api_url = Rhea.configuration.kube_api[:url]
+          root_url = api_url.sub('/api/', '/')
+          services_url = "#{api_url}v1/proxy/namespaces/kube-system/services/"
+          {
+            'Kubernetes UI' => "#{services_url}kube-ui/",
+            'Grafana' => "#{services_url}monitoring-grafana/",
+            'Kibana' => "#{services_url}kibana-logging/",
+            'Logs' => "#{services_url}logs/",
+            'Swagger UI' => "#{root_url}swagger-ui/"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rhea/version.rb

@@ -1,3 +1,3 @@
 module Rhea
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/rhea.gemspec

@@ -3,8 +3,8 @@ require File.expand_path('../lib/rhea/version', __FILE__)
 Gem::Specification.new do |s|
   s.authors       = ['Tom Benner']
   s.email         = ['tombenner@gmail.com']
-  s.description = s.summary = %q{}
-  s.homepage      = 'https://github.com/tombenner/rhea'
+  s.description = s.summary = %q{A web UI for managing a Kubernetes cluster}
+  s.homepage      = 'https://github.com/entelo/rhea'
 
   s.files         = `git ls-files`.split($\)
   s.name          = 'rhea'
@@ -12,5 +12,13 @@ Gem::Specification.new do |s|
   s.version       = Rhea::VERSION
   s.license       = 'MIT'
 
-  s.add_development_dependency 'rspec'
+  s.add_dependency 'kubeclient', '~> 0.3.0'
+  s.add_dependency 'haml', '~> 4.0'
+  s.add_dependency 'kaminari', '~> 0.16'
+  s.add_dependency 'sass-rails', '~> 5.0'
+
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'rspec-rails', '~> 3.0'
+  s.add_development_dependency 'vcr', '~> 2.9'
+  s.add_development_dependency 'webmock', '~> 1.8'
 end

data/spec/lib/rhea/kubernetes/commands/all_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Rhea::Kubernetes::Commands::All, :vcr do
+  include KubernetesSpecHelper
+
+  before(:each) { delete_replication_controllers }
+  after(:each) { delete_replication_controllers }
+
+  describe '#perform' do
+    context 'an existing rc' do
+      let(:process_count) { 1 }
+
+      before :each do
+        Rhea::Kubernetes::Commands::Scale.new(expression: command_expression, process_count: process_count).perform
+      end
+
+      it 'returns the rc' do
+        replication_controllers = described_class.new.perform
+        expected_attributes = {
+          expression: command_expression,
+          image: kube_image,
+          process_count: process_count
+        }
+        expect(replication_controllers.length).to eq(1)
+        expect(replication_controllers[0].attributes).to include(expected_attributes)
+      end
+    end
+  end
+end

data/spec/lib/rhea/kubernetes/commands/delete_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Rhea::Kubernetes::Commands::Delete, :vcr do
+  include KubernetesSpecHelper
+
+  before(:each) { delete_replication_controllers }
+  after(:each) { delete_replication_controllers }
+
+  describe '#perform' do
+    context 'an existing rc' do
+      before :each do
+        Rhea::Kubernetes::Commands::Scale.new(expression: command_expression, process_count: 1).perform
+      end
+
+      it 'deletes the rc' do
+        described_class.new(expression: command_expression).perform
+        url = "#{kube_authed_api_url}replicationcontrollers/#{kube_replication_controller_name}"
+        expect(WebMock).to have_requested(:delete, url)
+      end
+    end
+  end
+end

data/spec/lib/rhea/kubernetes/commands/export_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Rhea::Kubernetes::Commands::Export, :vcr do
+  include KubernetesSpecHelper
+
+  before(:each) { delete_replication_controllers }
+  after(:each) { delete_replication_controllers }
+
+  describe '#perform' do
+    context 'an existing rc' do
+      let(:process_count) { 1 }
+
+      before :each do
+        Rhea::Kubernetes::Commands::Scale.new(expression: command_expression, process_count: process_count).perform
+      end
+
+      it 'returns the data' do
+        data = described_class.new.perform
+        expect(data[:version]).to eq(Rhea::VERSION)
+        expect(data[:created_at]).to be_a(Time)
+        expect(data[:commands]).to eq([
+          {
+            expression: command_expression,
+            image: kube_image,
+            process_count: process_count
+          }
+        ])
+      end
+    end
+  end
+end

data/spec/lib/rhea/kubernetes/commands/get_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Rhea::Kubernetes::Commands::Get, :vcr do
+  include KubernetesSpecHelper
+
+  before(:each) { delete_replication_controllers }
+  after(:each) { delete_replication_controllers }
+
+  describe '#perform' do
+    context 'an existing rc' do
+      let(:process_count) { 1 }
+
+      before :each do
+        Rhea::Kubernetes::Commands::Scale.new(expression: command_expression, image: kube_image, process_count: process_count).perform
+      end
+
+      it 'gets the rc' do
+        replication_controller = described_class.new(expression: command_expression).perform
+        expected_attributes = {
+          expression: command_expression,
+          image: kube_image,
+          process_count: process_count
+        }
+        expect(replication_controller.attributes).to include(expected_attributes)
+      end
+    end
+  end
+end

data/spec/lib/rhea/kubernetes/commands/import_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Rhea::Kubernetes::Commands::Import, :vcr do
+  include KubernetesSpecHelper
+
+  before(:each) { delete_replication_controllers }
+  after(:each) { delete_replication_controllers }
+
+  describe '#perform' do
+    context 'no existing rcs' do
+      let(:process_count) { 1 }
+      let(:data) do
+        {
+          version: Rhea::VERSION,
+          created_at: Time.now,
+          commands: [
+            {
+              expression: command_expression,
+              image: kube_image,
+              process_count: process_count
+            }.stringify_keys
+          ]
+        }.stringify_keys
+      end
+
+      it 'creates the rcs' do
+        described_class.new(data).perform
+        replication_controllers = Rhea::Kubernetes::Commands::All.new.perform
+        expected_attributes = {
+          expression: command_expression,
+          image: kube_image,
+          process_count: process_count
+        }
+        expect(replication_controllers.length).to eq(1)
+        expect(replication_controllers[0].attributes).to include(expected_attributes)
+      end
+    end
+  end
+end

data/spec/lib/rhea/kubernetes/commands/redeploy_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Rhea::Kubernetes::Commands::Redeploy, :vcr do
+  include KubernetesSpecHelper
+
+  before(:each) { delete_replication_controllers }
+  after(:each) { delete_replication_controllers }
+
+  describe '#perform' do
+    context 'an existing rc' do
+      let(:process_count) { 2 }
+
+      before :each do
+        Rhea::Kubernetes::Commands::Scale.new(expression: command_expression, process_count: process_count).perform
+      end
+
+      it 'redeploys the rc' do
+        described_class.new(expression: command_expression).perform
+        replication_controller = Rhea::Kubernetes::Commands::Get.new(expression: command_expression).perform
+
+        expected_attributes = {
+          expression: command_expression,
+          image: kube_image,
+          process_count: process_count
+        }
+        expect(replication_controller.attributes).to include(expected_attributes)
+
+        # One POST for the initial creation, and a second POST for the recreation
+        expect(WebMock).to have_requested(:post, "#{kube_authed_api_url}replicationcontrollers").twice
+        expect(WebMock).to have_requested(:delete, "#{kube_authed_api_url}replicationcontrollers/#{kube_replication_controller_name}")
+        expect(WebMock).to have_requested(:put, "#{kube_authed_api_url}replicationcontrollers/#{kube_replication_controller_name}")
+      end
+    end
+  end
+end