scaltainer 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad9d8453d71a28ce6344fa3b5e8a3185cf21e613
-  data.tar.gz: 3033587d946ce00606b9420ff2645d36c617bd43
+  metadata.gz: 642f49828031f354f271d0ad4e28268ab40e1f1a
+  data.tar.gz: 2be74e2694d99bc5edde992e8e277867db0de44b
 SHA512:
-  metadata.gz: 503333de51f96a8d4df01410378cfd26b8b9db46d6023ed50949199396032ad4ef3c02e0da3baeb12e3f1bdb92721e69ef0ad3264d6b43cc4aa18ae3d9bff440
-  data.tar.gz: be2a993a5589276e95fc46145953b65c3a20ee53d3512ec7a85c8d00f06566dff436f4bf1e2723eda24ee52420a4f2da0de7236a0d45e85f824590ea3aadcac6
+  metadata.gz: 34a7ddda22e20d4e909a29c7b2183344712a7fc72dd8d970055c578834e6d1707496bfeebfd09cc4224d62a806615756cb964bddb07653b60798ded0ffe0cbe8
+  data.tar.gz: 07b3b919496e8cc1fbdbc25199e53509e5bb44b3be47a0257430ce6be22102dc08eb43e7d6a2e9bc2eb6ef2ad8d0d33b84ebec9a5c4be8ee83b5094df7e25bc5

data/.dockerignore

@@ -0,0 +1,3 @@
+pkg
+spec
+.env

data/.gitignore

@@ -6,4 +6,8 @@
 /pkg/
 /spec/reports/
 /tmp/
-Gemfile.lock
+Gemfile.lock
+.env
+scaltainer.yml
+scaltainer.yml.state
+kube-manifest.yaml

data/Dockerfile

@@ -1,8 +1,10 @@
 FROM ruby:2.3
 
-MAINTAINER Hossam Hammady <github@hammady.net>
+label maintainer="Hossam Hammady <github@hammady.net>"
 
-RUN gem install scaltainer
+WORKDIR /home
+COPY / /home/
+RUN bundle install && bundle exec rake install
 
 ENTRYPOINT ["scaltainer"]
 

data/README.md

@@ -4,32 +4,38 @@
 
 # Scaltainer
 
-A Ruby gem to monitor docker swarm mode services and auto-scale them based on user configuration.
+A Ruby gem to monitor Docker Swarm mode services and Kubernetes resources
+and auto-scale them based on user configuration.
 It can be used to monitor web services and worker services. The web services type has metrics like response time using [New Relic](https://newrelic.com/). The worker services type metrics are basically the queue size for each.
 This gem is inspired by [HireFire](https://manager.hirefire.io/) and was indeed motivated by the migration
-from [Heroku](https://www.heroku.com/) to Docker Swarm mode.
+from [Heroku](https://www.heroku.com/) to Docker.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-```ruby
-gem 'scaltainer'
-```
+Install using rubygems:
 
-And then execute:
+    $ gem install scaltainer
 
-    $ bundle
+## Usage
 
-Or install it yourself as:
+For Docker swarm:
 
-    $ gem install scaltainer
+    scaltainer -o swarm
 
-## Usage
+Or simply:
 
     scaltainer
 
-This will do a one-time check on the running service replicas and sends scaling out/in commands to the swarm cluster as appropriate.
+For Kubernetes:
+
+    scaltainer -o kubernetes
+
+
+This will do a one-time check on the running docker service replicas
+or Kubernetes replication controllers, replica sets, or deployments.
+Then it sends scaling out/in commands to the cluster as appropriate.
 Configuration is read from `scaltainer.yml` by default. If you want to read from another file add `-f yourconfig.yml`:
 
     scaltainer -f yourconfig.yml
@@ -47,15 +53,44 @@ specify the wait time between repetitions using the `-w` parameter in seconds:
 
     scaltainer -w 60
 
-This will repeatedly call scaltainer every 60 seconds, sleeping in between.
+This will repeatedly call scaltainer every 60 seconds, sleeping in-between.
 
 ## Configuration
 
 ### Environment variables
 
+#### Docker swarm options
+
 - `DOCKER_URL`: Should point to the docker engine URL.
 If not set, it defaults to local unix socket.
 
+#### Kubernetes options
+
+- `KUBECONFIG`: set to Kubernetes config
+(default: `$HOME/.kube/config`) if you want to connect
+to the current configured cluster.
+
+- `KUBERNETES_API_SERVER`: overrides option in `KUBECONFIG`
+and defaults to `https://kubernetes.default:443`.
+
+- `KUBERNETES_SKIP_SSL_VERIFY`: `KUBECONFIG` option overrides
+this, set to any value to skip SSL verification.
+
+- `KUBERNETES_API_ENDPOINT`: defaults to `/api`.
+
+- `KUBERNETES_API_VERSION`: overrides option in `KUBECONFIG`
+and defaults to `v1`.
+
+- `KUBERNETES_CONTROLLER_KIND`: controller kind to scale,
+allowed values: `deployment` (default),
+`replication_controller`, or `replica_set`.
+
+Make sure the `KUBERNETES_CONTROLLER_KIND` you specify is
+part of the api specified using `KUBERNETES_API_ENDPOINT`
+and `KUBERNETES_API_VERSION`.
+
+#### General options
+
 - `HIREFIRE_TOKEN`: If your application is configured the
 [hirefire](https://help.hirefire.io/guides/hirefire/job-queue-any-programming-language) way, you need to
 set `HIREFIRE_TOKEN` environment variable before invoking
@@ -86,8 +121,8 @@ The configuration file (determined by `-f FILE` command line parameter) should b
 
     # to get worker metrics
     endpoint: https://your-app.com/hirefire/$HIREFIRE_TOKEN/info
-    # optional docker swarm stack name
-    stack_name: mystack
+    # optional docker swarm stack name or kubernetes namespace
+    namespace: mynamespace
     # list of web services to monitor
     web_services:
       # each service name should match docker service name
@@ -126,25 +161,15 @@ The configuration file (determined by `-f FILE` command line parameter) should b
 
 More details about configuration parameters can be found in [HireFire docs](https://help.hirefire.io/guides).
 
-## Docker installation and usage
+## Docker Swarm usage
 
-Scaltainer is availabe on Docker Hub, so you can `docker run` it:
-
-    docker run -it --rm rayyanqcri/scaltainer
-
-Which will print the usage. To add arguments, just append them:
-
-    docker run -it --rm rayyanqcri/scaltainer -f scaltainer.yml
-
-Scaltainer should typically be run as a minutely cron service.
-If you are using [rayyanqcri/swarm-scheduler](https://github.com/rayyanqcri/swarm-scheduler),
-a service definition for scaltainer is typically something like this:
+A service definition for scaltainer is typically something like this:
 
     version: '3.3'
     services:
       scaltainer:
         image: rayyanqcri/scaltainer:latest
-        command: -f /scaltainer.yml --state-file /tmp/scaltainer-state.yml
+        command: -f /scaltainer.yml --state-file /tmp/scaltainer-state.yml -w 60
         volumes:
           - /var/run/docker.sock:/var/run/docker.sock
         environment:
@@ -157,9 +182,7 @@ a service definition for scaltainer is typically something like this:
         secrets:
           - scaltainer
         deploy:
-          replicas: 0
-          restart_policy:
-            condition: none
+          replicas: 1
           placement:
             constraints:
               - node.role == manager
@@ -177,6 +200,75 @@ Where `scaltainer.env` is a file containing HireFire and NewRelic secrets:
 
 And `scaltainer.yml` is the scaltainer configuration file.
 
+## Kubernetes usage
+
+### Create a ConfigMap
+
+    kubectl create configmap scaltainer --from-file=scaltainer.yaml=/path/to/your/scaltainer.yml
+
+Where `/path/to/your/scaltainer.yml` is the scaltainer configuration file.
+
+### Create a Secret
+
+    kubectl create secret generic scaltainer --from-env-file=/path/to/scaltainer.env
+
+Where `/path/to/scaltainer.env` is a file containing HireFire and NewRelic secrets:
+
+    HIREFIRE_TOKEN=
+    NEW_RELIC_API_KEY=
+
+### Create a Deployment:
+
+    kubectl apply -f scaltainer-kube.yaml
+
+Where scaltainer-kube.yaml has the following content:
+
+    apiVersion: extensions/v1beta1
+    kind: Deployment
+    metadata:
+      labels:
+        app: scaltainer
+      name: scaltainer
+    spec:
+      replicas: 1
+      template:
+        metadata:
+          labels:
+            app: scaltainer
+        spec:
+          containers:
+          - image: rayyanqcri/scaltainer:latest
+            name: scaltainer
+            args:
+              - -o
+              - kubernetes
+              - -f
+              - /etc/config/scaltainer.yaml
+              - --state-file
+              - /tmp/scaltainer-state.yaml
+              - -w
+              - "60"
+            env:
+            - name: KUBERNETES_SKIP_SSL_VERIFY
+              value: "yes"
+            - name: KUBERNETES_API_ENDPOINT
+              value: /apis/extensions
+            - name: KUBERNETES_API_VERSION
+              value: v1beta1
+            - name: KUBERNETES_CONTROLLER_KIND
+              value: deployment
+            envFrom:
+            - secretRef:
+                name: scaltainer
+            volumeMounts:
+            - name: scaltainer-config
+              mountPath: "/etc/config"
+          volumes:
+          - name: scaltainer-config
+            configMap:
+              name: scaltainer
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -187,9 +279,9 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/hammady/scaltainer.
 
-## TODOs
+## Testing
 
-- Rspec
+    rake
 
 ## License
 

data/exe/scaltainer

@@ -3,8 +3,8 @@
 require 'scaltainer'
 
 begin
-  configfile, statefile, logger, wait = Scaltainer::Command.parse ARGV
-  Scaltainer::Runner.new configfile, statefile, logger, wait
+  configfile, statefile, logger, wait, orchestrator = Scaltainer::Command.parse ARGV
+  Scaltainer::Runner.new configfile, statefile, logger, wait, orchestrator
 rescue => e
   $stderr.puts e.message
   $stderr.puts e.backtrace

data/lib/scaltainer.rb

@@ -3,6 +3,6 @@ require "scaltainer/exceptions"
 require "scaltainer/service_types"
 require "scaltainer/runner"
 require "scaltainer/command"
-require "scaltainer/docker/service"
+require "scaltainer/orchestrators"
 require "scaltainer/newrelic/metrics"
 require "json"

data/lib/scaltainer/command.rb

@@ -4,7 +4,7 @@ require "optparse"
 module Scaltainer
   class Command
     def self.parse(args)
-      configfile, statefile, wait = 'scaltainer.yml', nil, 0
+      configfile, statefile, wait, orchestrator = 'scaltainer.yml', nil, 0, :swarm
       OptionParser.new do |opts|
         opts.banner = "Usage: scaltainer [options]"
         opts.on("-f", "--conf-file FILE", "Specify configuration file (default: scaltainer.yml)") do |file|
@@ -16,10 +16,27 @@ module Scaltainer
         opts.on("-w", "--wait SECONDS", "Specify wait time between repeated calls, 0 for no repetition (default: 0)") do |w|
           wait = w.to_i
         end
+        opts.on("-o", "--orchestrator swarm:kubernetes", [:swarm, :kubernetes], "Specify orchestrator type (default: swarm)") do |o|
+          orchestrator = o
+        end
+        opts.on("-v", "--version", "Show version and exit") do
+          puts Scaltainer::VERSION
+          exit 0
+        end
         opts.on_tail("-h", "--help", "Show this message") do
           puts opts
           puts "\nEnvironment variables: \n"
+          puts "Docker Swarm options:"
           puts "- DOCKER_URL: defaults to local socket"
+          puts "Kubernetes options:"
+          puts "- KUBECONFIG: set to Kubernetes config (default: $HOME/.kube/config) if you want to connect to the current configured cluster"
+          puts "- KUBERNETES_API_SERVER: overrides option in KUBECONFIG and defaults to https://kubernetes.default:443"
+          puts "- KUBERNETES_SKIP_SSL_VERIFY: KUBECONFIG option overrides this, set to any value to skip SSL verification"
+          puts "- KUBERNETES_API_ENDPOINT: defaults to /api"
+          puts "- KUBERNETES_API_VERSION: overrides option in KUBECONFIG and defaults to v1"
+          puts "- KUBERNETES_CONTROLLER_KIND: controller kind to scale, allowed values: deployment (default), replication_controller, or replica_set"
+          puts "  Make sure the KUBERNETES_CONTROLLER_KIND you specify is part of the api specified using KUBERNETES_API_ENDPOINT and KUBERNETES_API_VERSION"
+          puts "General options:"
           puts "- HIREFIRE_TOKEN"
           puts "- NEW_RELIC_API_KEY"
           puts "- RESPONSE_TIME_WINDOW: defaults to 5"
@@ -38,7 +55,7 @@ module Scaltainer
       logger = Logger.new(STDOUT)
       logger.level = %w(debug info warn error fatal unknown).find_index((ENV['LOG_LEVEL'] || '').downcase) || 1
 
-      return configfile, statefile, logger, wait
+      return configfile, statefile, logger, wait, orchestrator
     end
 
     private

data/lib/scaltainer/orchestrators.rb

@@ -0,0 +1,3 @@
+require "scaltainer/orchestrators/base"
+require "scaltainer/orchestrators/swarm"
+require "scaltainer/orchestrators/kubernetes"

data/lib/scaltainer/orchestrators/base.rb

@@ -0,0 +1,17 @@
+module Scaltainer
+  class ReplicaSetBase
+    attr_accessor :id, :name, :type, :namespace
+
+    def initialize(name, type, namespace)
+      @name, @type, @namespace = name, type, namespace
+    end
+
+    def get_replicas
+      raise 'Abstract method, please override'
+    end
+
+    def set_replicas(replicas)
+      raise 'Abstract method, please override'
+    end
+  end
+end

data/lib/scaltainer/orchestrators/kubernetes.rb

@@ -0,0 +1,84 @@
+require 'kubeclient'
+
+module Scaltainer
+  class KubeResource < ReplicaSetBase
+    def initialize(name, namespace)
+      @@client ||= self.class.get_client
+      type = ENV['KUBERNETES_CONTROLLER_KIND'] || 'deployment'
+      # if namespace not specified, use the one found in configuration
+      namespace ||= @@namespace || 'default'
+      super(name, type, namespace)
+      @resource = @@client.send("get_#{@type}", normalize_name(@name), @namespace)
+      @id = @resource.metadata.uid
+    end
+
+    def get_replicas
+      @resource.spec.replicas
+    end
+
+    def set_replicas(replicas)
+      @@client.send("patch_#{@type}", normalize_name(@name), {spec: {replicas: replicas}}, @namespace)
+    end
+
+    private
+
+    def self.get_client
+      if ENV['KUBECONFIG']
+        get_client_from_kubeconfig ENV['KUBECONFIG']
+      else
+        get_client_from_serviceaccount '/var/run/secrets/kubernetes.io/serviceaccount'
+      end
+    end
+
+    def self.get_client_from_kubeconfig(kubeconfig)
+      config = Kubeclient::Config.read(kubeconfig)
+      url = get_api_url(config.context.api_endpoint)
+      version = get_api_version(config.context.api_version)
+      # @@namespace = config.context.namespace # wait till PR#308 merged into kubeclient
+      Kubeclient::Client.new(
+        url, version,
+        ssl_options: config.context.ssl_options,
+        auth_options: config.context.auth_options
+      )
+    end
+
+    def self.get_client_from_serviceaccount(serviceaccount)
+      ssl_verify = if ENV['KUBERNETES_SKIP_SSL_VERIFY']
+        OpenSSL::SSL::VERIFY_NONE
+      else
+        OpenSSL::SSL::VERIFY_PEER
+      end
+      ssl_options = {
+        client_cert: OpenSSL::X509::Certificate.new(read_secret(serviceaccount, 'ca.crt')),
+        verify_ssl: ssl_verify
+      }
+      auth_options = {bearer_token: read_secret(serviceaccount, 'token')}
+      @@namespace = read_secret(serviceaccount, 'namespace')
+      url = get_api_url('https://kubernetes.default:443')
+      version = get_api_version('v1')
+      Kubeclient::Client.new(
+        url, version,
+        ssl_options: ssl_options,
+        auth_options: auth_options
+      )
+    end
+
+    def self.get_api_url(default_server)
+      server = ENV['KUBERNETES_API_SERVER'] || default_server
+      endpoint = ENV['KUBERNETES_API_ENDPOINT'] || '/api'
+      "#{server}#{endpoint}"
+    end
+
+    def self.get_api_version(default_version)
+      ENV['KUBERNETES_API_VERSION'] || default_version
+    end
+
+    def self.read_secret(serviceaccount, secret)
+      File.read("#{serviceaccount}/#{secret}")
+    end
+
+    def normalize_name(name)
+      name.gsub(/_/, '-')
+    end
+  end
+end

data/lib/scaltainer/{docker/service.rb → orchestrators/swarm.rb}

@@ -1,3 +1,26 @@
+module Scaltainer
+  class DockerService < ReplicaSetBase
+    def initialize(service_name, namespace)
+      # set logger?
+      full_name = namespace ? "#{namespace}_#{service_name}" : service_name
+      @service = Docker::Service.all(filters: {name: [full_name]}.to_json)[0]
+      raise "Docker Service not found: #{full_name}" unless @service
+      @id = @service.id
+      super(service_name, 'service', namespace)
+    end
+
+    def get_replicas
+      replicated = @service.info["Spec"]["Mode"]["Replicated"]
+      raise ConfigurationError.new "Cannot replicate a global service: #{@name}" unless replicated
+      replicated["Replicas"]
+    end
+
+    def set_replicas(replicas)
+      @service.scale replicas
+    end
+  end
+end
+
 # source: https://github.com/Stazer/docker-api/blob/feature/swarm_support/lib/docker/service.rb
 
 # This class represents a Docker Service. It's important to note that nothing

data/lib/scaltainer/runner.rb

@@ -2,7 +2,8 @@ require "yaml"
 
 module Scaltainer
   class Runner
-    def initialize(configfile, statefile, logger, wait)
+    def initialize(configfile, statefile, logger, wait, orchestrator)
+      @orchestrator = orchestrator
       @logger = logger
       @default_service_config = {
         "min" => 0,
@@ -13,7 +14,7 @@ module Scaltainer
       }
       @logger.debug "Scaltainer initialized with configuration file: #{configfile}, and state file: #{statefile}"
       config = YAML.load_file configfile
-      Docker.logger = @logger
+      Docker.logger = @logger if orchestrator == :swarm
       state = get_state(statefile) || {}
       endpoint = config["endpoint"]
       service_type_web = ServiceTypeWeb.new(endpoint)
@@ -29,9 +30,9 @@ module Scaltainer
     private
 
     def run(config, state, service_type_web, service_type_worker)
-      service_prefix = config["stack_name"]
-      iterate_services config["web_services"], service_prefix, service_type_web, state
-      iterate_services config["worker_services"], service_prefix, service_type_worker, state
+      namespace = config["namespace"] || config["stack_name"]
+      iterate_services config["web_services"], namespace, service_type_web, state
+      iterate_services config["worker_services"], namespace, service_type_worker, state
     end
 
     def get_state(statefile)
@@ -42,35 +43,18 @@ module Scaltainer
       File.write(statefile, state.to_yaml)
     end
 
-    def get_service(service_name)
-      begin
-        service = Docker::Service.all(filters: {name: [service_name]}.to_json)[0]
-      rescue => e
-        raise NetworkError.new "Could not get service with name #{service_name} from docker engine at #{Docker.url}.\n#{e.message}"
-      end
-      raise ConfigurationError.new "Unknown service to docker: #{service_name}" unless service
-      service
-    end
-
-    def get_service_replicas(service)
-      # ask docker about replicas for service
-      replicated = service.info["Spec"]["Mode"]["Replicated"]
-      raise ConfigurationError.new "Cannot replicate a global service: #{service.info['Spec']['Name']}" unless replicated
-      replicated["Replicas"]
-    end
-
-    def iterate_services(services, service_prefix, type, state)
+    def iterate_services(services, namespace, type, state)
       begin
         metrics = type.get_metrics services
-        @logger.debug "Retrieved metrics for #{type} services: #{metrics}"
+        @logger.debug "Retrieved metrics for #{type} resources: #{metrics}"
         services.each do |service_name, service_config|
           begin
             state[service_name] ||= {}
             service_state = state[service_name]
-            @logger.debug "Service #{service_name} currently has state: #{service_state}"
+            @logger.debug "Resource #{service_name} in namespace #{namespace} currently has state: #{service_state}"
             service_config = @default_service_config.merge service_config
-            @logger.debug "Service #{service_name} configuration: #{service_config}"
-            process_service service_name, service_config, service_state, service_prefix, type, metrics
+            @logger.debug "Resource #{service_name} in namespace #{namespace} configuration: #{service_config}"
+            process_service service_name, service_config, service_state, namespace, type, metrics
           rescue RuntimeError => e
             # skipping service
             log_exception e
@@ -86,34 +70,46 @@ module Scaltainer
       @logger.log (e.class == Scaltainer::Warning ? Logger::WARN : Logger::ERROR), e.message
     end
 
-    def process_service(service_name, config, state, prefix, type, metrics)
-      full_service_name = prefix ? "#{prefix}_#{service_name}" : service_name
-      service = get_service full_service_name
-      @logger.debug "Found service at docker with name '#{service_name}' and id '#{service.id}'"
-      current_replicas = get_service_replicas service
-      @logger.debug "Service #{service_name} is currently configured for #{current_replicas} replica(s)"
-      metric = metrics[service_name]
-      raise Scaltainer::Warning.new("Configured service '#{service_name}' not found in metrics endpoint") unless metric
+    def process_service(service_name, config, state, namespace, type, metrics)
+      service = get_service service_name, namespace
+      @logger.debug "Found #{service.type} at orchestrator with name '#{service.name}' and id '#{service.id}'"
+      current_replicas = service.get_replicas
+      @logger.debug "#{service.type.capitalize} #{service.name} is currently configured for #{current_replicas} replica(s)"
+      metric = metrics[service.name]
+      raise Scaltainer::Warning.new("Configured #{service.type} '#{service.name}' not found in metrics endpoint") unless metric
       desired_replicas = type.determine_desired_replicas metric, config, current_replicas
-      @logger.debug "Desired number of replicas for service #{service_name} is #{desired_replicas}"
+      @logger.debug "Desired number of replicas for #{service.type} #{service.name} is #{desired_replicas}"
       adjusted_replicas = type.adjust_desired_replicas(desired_replicas, config)
-      @logger.debug "Desired number of replicas for service #{service_name} is adjusted to #{adjusted_replicas}"
+      @logger.debug "Desired number of replicas for #{service.type} #{service.name} is adjusted to #{adjusted_replicas}"
       replica_diff = adjusted_replicas - current_replicas
       type.yield_to_scale(replica_diff, config, state, metric,
-        service_name, @logger) do
+        service.name, @logger) do
           scale_out service, current_replicas, adjusted_replicas
         end
     end
 
+    def get_service(service_name, namespace)
+      begin
+        service = if @orchestrator == :swarm
+          DockerService.new service_name, namespace
+        elsif @orchestrator == :kubernetes
+          KubeResource.new service_name, namespace
+        end
+      rescue => e
+        raise NetworkError.new "Could not find resource with name #{service_name} in namespace #{namespace}: #{e.message}"
+      end
+      raise ConfigurationError.new "Unknown resource: #{service_name} in namespace #{namespace}" unless service
+      service
+    end
+
     def scale_out(service, current_replicas, desired_replicas)
       return if current_replicas == desired_replicas
-      # send scale command to docker
-      service_name = service.info['Spec']['Name']
-      @logger.info "Scaling #{service_name} from #{current_replicas} to #{desired_replicas}"
+      # send scale command to orchestrator
+      @logger.info "Scaling #{service.type} #{service.name} from #{current_replicas} to #{desired_replicas}"
       begin
-        service.scale desired_replicas
+        service.set_replicas desired_replicas
       rescue => e
-        raise NetworkError.new "Could not scale service #{service_name} due to docker engine error at #{Docker.url}.\n#{e.message}"
+        raise NetworkError.new "Could not scale #{service.type} #{service.name} due to error: #{e.message}"
       end
     end
 

data/lib/scaltainer/service_types/base.rb

@@ -6,12 +6,12 @@ module Scaltainer
 
     def get_metrics(services)
       services_count = services.keys.length rescue 0
-      raise Scaltainer::Warning.new "No services found for #{self.class.name}" if services_count == 0
+      raise Scaltainer::Warning.new "No resources found for #{self.class.name}" if services_count == 0
     end
 
     def determine_desired_replicas(metric, service_config, current_replicas)
-      raise ConfigurationError.new 'No metric found for requested service' unless metric
-      raise ConfigurationError.new 'No configuration found for requested service' unless service_config
+      raise ConfigurationError.new 'No metric found for requested resource' unless metric
+      raise ConfigurationError.new 'No configuration found for requested resource' unless service_config
     end
 
     def adjust_desired_replicas(desired_replicas, config)
@@ -32,7 +32,7 @@ module Scaltainer
           yield
           state["upscale_sensitivity"] = 0
         else
-          logger.debug "Scaling up of service #{service_name} blocked by upscale_sensitivity at level " +
+          logger.debug "Scaling up of resource #{service_name} blocked by upscale_sensitivity at level " +
             "#{state["upscale_sensitivity"]} while level #{config["upscale_sensitivity"]} is required"
         end
       elsif replica_diff < 0  # TODO force down when above max?
@@ -45,17 +45,17 @@ module Scaltainer
             yield
             state["downscale_sensitivity"] = 0
           else
-            logger.debug "Scaling down of service #{service_name} blocked by downscale_sensitivity at level " +
+            logger.debug "Scaling down of resource #{service_name} blocked by downscale_sensitivity at level " +
               "#{state["downscale_sensitivity"]} while level #{config["downscale_sensitivity"]} is required"
           end
         else
-          logger.debug "Scaling down of service #{service_name} to #{metric} replicas blocked by a non-decrementable config"
+          logger.debug "Scaling down of resource #{service_name} to #{metric} replicas blocked by a non-decrementable config"
         end
       else
         # no breach, change state
         state["upscale_sensitivity"] = 0
         state["downscale_sensitivity"] = 0
-        logger.info "No need to scale service #{service_name}"
+        logger.info "No need to scale resource #{service_name}"
       end
     end
 

data/lib/scaltainer/service_types/web.rb

@@ -14,7 +14,7 @@ module Scaltainer
 
       services.reduce({}) do |hash, (service_name, service_config)|
         app_id = service_config["newrelic_app_id"]
-        raise ConfigurationError.new "Service #{service_name} does not have a corresponding newrelic_app_id" unless app_id
+        raise ConfigurationError.new "Resource #{service_name} does not have a corresponding newrelic_app_id" unless app_id
 
         begin
           metric = nr.get_avg_response_time app_id, from, to
@@ -28,8 +28,8 @@ module Scaltainer
 
     def determine_desired_replicas(metric, service_config, current_replicas)
       super
-      raise ConfigurationError.new "Missing max_response_time in web service configuration" unless service_config["max_response_time"]
-      raise ConfigurationError.new "Missing min_response_time in web service configuration" unless service_config["min_response_time"]
+      raise ConfigurationError.new "Missing max_response_time in web resource configuration" unless service_config["max_response_time"]
+      raise ConfigurationError.new "Missing min_response_time in web resource configuration" unless service_config["min_response_time"]
       unless service_config["min_response_time"] <= service_config["max_response_time"]
         raise ConfigurationError.new "min_response_time and max_response_time are not in order"
       end

data/lib/scaltainer/service_types/worker.rb

@@ -21,7 +21,7 @@ module Scaltainer
 
     def determine_desired_replicas(metric, service_config, current_replicas)
       super
-      raise ConfigurationError.new "Missing ratio in worker service configuration" unless service_config["ratio"]
+      raise ConfigurationError.new "Missing ratio in worker resource configuration" unless service_config["ratio"]
       if !metric.is_a?(Integer) || metric < 0
         raise ConfigurationError.new "#{metric} is an invalid metric value, must be a non-negative number" 
       end

data/lib/scaltainer/version.rb

@@ -1,3 +1,3 @@
 module Scaltainer
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

data/scaltainer.gemspec

@@ -30,5 +30,6 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'excon', '>= 0.47.0'
   spec.add_runtime_dependency "docker-api"
+  spec.add_runtime_dependency "kubeclient"
   spec.add_runtime_dependency "dotenv"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scaltainer
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Hossam Hammady
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-30 00:00:00.000000000 Z
+date: 2018-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: kubeclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -132,6 +146,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".dockerignore"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -145,9 +160,12 @@ files:
 - exe/scaltainer
 - lib/scaltainer.rb
 - lib/scaltainer/command.rb
-- lib/scaltainer/docker/service.rb
 - lib/scaltainer/exceptions.rb
 - lib/scaltainer/newrelic/metrics.rb
+- lib/scaltainer/orchestrators.rb
+- lib/scaltainer/orchestrators/base.rb
+- lib/scaltainer/orchestrators/kubernetes.rb
+- lib/scaltainer/orchestrators/swarm.rb
 - lib/scaltainer/runner.rb
 - lib/scaltainer/service_types.rb
 - lib/scaltainer/service_types/base.rb