aptible-cli 0.21.0 → 0.23.0

data/lib/aptible/cli/subcommands/services.rb

@@ -21,6 +21,177 @@ module Aptible
                 end
               end
             end
+
+            desc 'services:settings SERVICE'\
+                   ' [--force-zero-downtime|--no-force-zero-downtime]'\
+                   ' [--simple-health-check|--no-simple-health-check]',
+                 'Modifies the zero-downtime deploy setting for a service'
+            app_options
+            option :force_zero_downtime,
+                   type: :boolean, default: false,
+                   desc: 'Force zero downtime deployments.'\
+                   ' Has no effect if service has an associated Endpoint'
+            option :simple_health_check,
+                   type: :boolean, default: false,
+                   desc: 'Use a simple uptime healthcheck during deployments'
+            define_method 'services:settings' do |service|
+              service = ensure_service(options, service)
+              updates = {}
+              updates[:force_zero_downtime] =
+                options[:force_zero_downtime] if options[:force_zero_downtime]
+              updates[:naive_health_check] =
+                options[:simple_health_check] if options[:simple_health_check]
+
+              service.update!(**updates) if updates.any?
+            end
+
+            desc 'services:sizing_policy SERVICE',
+                 'Returns the associated sizing policy, if any'
+            app_options
+            define_method 'services:sizing_policy' do |service|
+              service = ensure_service(options, service)
+              policy = service.service_sizing_policy
+
+              unless policy
+                raise Thor::Error, "Service #{service} does not have a " \
+                  'service sizing policy set'
+              end
+
+              Formatter.render(Renderer.current) do |root|
+                root.object do |node|
+                  ResourceFormatter.inject_service_sizing_policy(
+                    node, policy, service
+                  )
+                end
+              end
+            end
+
+            desc 'services:sizing_policy:set SERVICE '\
+                   '--autoscaling-type (horizontal|vertical) '\
+                   '[--metric-lookback-seconds SECONDS] '\
+                   '[--percentile PERCENTILE] '\
+                   '[--post-scale-up-cooldown-seconds SECONDS] '\
+                   '[--post-scale-down-cooldown-seconds SECONDS] '\
+                   '[--post-release-cooldown-seconds SECONDS] '\
+                   '[--mem-cpu-ratio-r-threshold RATIO] '\
+                   '[--mem-cpu-ratio-c-threshold RATIO] '\
+                   '[--mem-scale-up-threshold THRESHOLD] '\
+                   '[--mem-scale-down-threshold THRESHOLD] '\
+                   '[--minimum-memory MEMORY] '\
+                   '[--maximum-memory MEMORY] '\
+                   '[--min-cpu-threshold THRESHOLD] '\
+                   '[--max-cpu-threshold THRESHOLD] '\
+                   '[--min-containers CONTAINERS] '\
+                   '[--max-containers CONTAINERS] '\
+                   '[--scale-up-step STEPS] '\
+                   '[--scale-down-step STEPS] ',
+                 'Sets the sizing (autoscaling) policy for a service.'\
+                   ' This is not incremental, all arguments must be sent'\
+                   ' at once or they will be set to defaults.'
+            app_options
+            option :autoscaling_type,
+                   type: :string,
+                   desc: 'The type of autoscaling. Must be either '\
+                   '"horizontal" or "vertical"'
+            option :metric_lookback_seconds,
+                   type: :numeric,
+                   desc: '(Default: 1800) The duration in seconds for '\
+                   'retrieving past performance metrics.'
+            option :percentile,
+                   type: :numeric,
+                   desc: '(Default: 99) The percentile for evaluating metrics.'
+            option :post_scale_up_cooldown_seconds,
+                   type: :numeric,
+                   desc: '(Default: 60) The waiting period in seconds after '\
+                   'an automated scale-up before another scaling action can '\
+                   'be considered.'
+            option :post_scale_down_cooldown_seconds,
+                   type: :numeric,
+                   desc: '(Default: 300) The waiting period in seconds after '\
+                   'an automated scale-down before another scaling action can '\
+                   'be considered.'
+            option :post_release_cooldown_seconds,
+                   type: :numeric,
+                   desc: '(Default: 300) The time in seconds to wait '\
+                   'following a deploy before another scaling action can '\
+                   'be considered.'
+            option :mem_cpu_ratio_r_threshold,
+                   type: :numeric,
+                   desc: '(Default: 4.0) Establishes the ratio of Memory '\
+                   '(in GB) to CPU (in CPUs) at which values exceeding the '\
+                   'threshold prompt a shift to an R (Memory Optimized) '\
+                   'profile.'
+            option :mem_cpu_ratio_c_threshold,
+                   type: :numeric,
+                   desc: '(Default: 2.0) Sets the Memory-to-CPU ratio '\
+                   'threshold, below which the service is transitioned to a '\
+                   'C (Compute Optimized) profile.'
+            option :mem_scale_up_threshold,
+                   type: :numeric,
+                   desc: '(Default: 0.9) Vertical autoscaling only - '\
+                   'Specifies the percentage of the current memory limit '\
+                   'at which the service’s memory usage triggers an '\
+                   'up-scaling action.'
+            option :mem_scale_down_threshold,
+                   type: :numeric,
+                   desc: '(Default: 0.75) Vertical autoscaling only - '\
+                   'Specifies the percentage of the current memory limit at '\
+                   'which the service’s memory usage triggers a '\
+                   'down-scaling action.'
+            option :minimum_memory,
+                   type: :numeric,
+                   desc: '(Default: 2048) Vertical autoscaling only - Sets '\
+                   'the lowest memory limit to which the service can be '\
+                   'scaled down by Autoscaler.'
+            option :maximum_memory,
+                   type: :numeric,
+                   desc: 'Vertical autoscaling only - Defines the upper '\
+                   'memory threshold, capping the maximum memory allocation'\
+                   ' possible through Autoscaler. If blank, the container can'\
+                   ' scale to the largest size available.'
+            option :min_cpu_threshold,
+                   type: :numeric,
+                   desc: 'Horizontal autoscaling only - Specifies the '\
+                   'percentage of the current CPU usage at which a '\
+                   'down-scaling action is triggered.'
+            option :max_cpu_threshold,
+                   type: :numeric,
+                   desc: 'Horizontal autoscaling only - Specifies the '\
+                   'percentage of the current CPU usage at which an '\
+                   'up-scaling action is triggered.'
+            option :min_containers,
+                   type: :numeric,
+                   desc: 'Horizontal autoscaling only - Sets the lowest'\
+                   ' container count to which the service can be scaled down.'
+            option :max_containers,
+                   type: :numeric,
+                   desc: 'Horizontal autoscaling only - Sets the highest '\
+                   'container count to which the service can be scaled up to.'
+            option :scale_up_step,
+                   type: :numeric,
+                   desc: '(Default: 1) Horizontal autoscaling only - Sets '\
+                   'the amount of containers to add when autoscaling (ex: a '\
+                   'value of 2 will go from 1->3->5). Container count will '\
+                   'never exceed the configured maximum.'
+            option :scale_down_step,
+                   type: :numeric,
+                   desc: '(Default: 1) Horizontal autoscaling only - Sets '\
+                   'the amount of containers to remove when autoscaling (ex:'\
+                   ' a value of 2 will go from 4->2->1). Container count '\
+                   'will never exceed the configured minimum.'
+            define_method 'services:sizing_policy:set' do |service|
+              service = ensure_service(options, service)
+              ignored_attrs = %i(autoscaling_type app environment remote)
+              args = options.except(*ignored_attrs)
+              args[:autoscaling] = options[:autoscaling_type]
+
+              sizing_policy = service.service_sizing_policy
+              if sizing_policy
+                sizing_policy.update!(**args)
+              else
+                service.create_service_sizing_policy!(**args)
+              end
+            end
           end
         end
       end

data/lib/aptible/cli/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module CLI
-    VERSION = '0.21.0'.freeze
+    VERSION = '0.23.0'.freeze
   end
 end

data/spec/aptible/cli/subcommands/endpoints_spec.rb

@@ -452,6 +452,30 @@ describe Aptible::CLI::Agent do
       end
     end
 
+    describe 'endpoints:grpc:create' do
+      m = 'endpoints:grpc:create'
+      include_examples 'shared create app vhost examples', m
+      include_examples 'shared create tls vhost examples', m
+
+      it 'creates a gRPC Endpoint' do
+        expect_create_vhost(
+          service,
+          type: 'grpc',
+          platform: 'elb',
+          internal: false,
+          default: false,
+          ip_whitelist: []
+        )
+        subject.send(m, 'web')
+      end
+
+      it 'creates an Endpoint with a container Port' do
+        expect_create_vhost(service, container_port: 10)
+        stub_options(port: 10)
+        subject.send(m, 'web')
+      end
+    end
+
     shared_examples 'shared modify app vhost examples' do |m|
       it 'does not change anything if no options are passed' do
         v = Fabricate(:vhost, service: service)
@@ -579,6 +603,20 @@ describe Aptible::CLI::Agent do
       end
     end
 
+    describe 'endpoints:grpc:modify' do
+      m = 'endpoints:grpc:modify'
+      include_examples 'shared modify app vhost examples', m
+      include_examples 'shared modify tls vhost examples', m
+
+      it 'allows updating the Container Port' do
+        v = Fabricate(:vhost, service: service)
+        expect_modify_vhost(v, container_port: 10)
+
+        stub_options(port: 10)
+        subject.send(m, v.external_host)
+      end
+    end
+
     describe 'endpoints:list' do
       it 'lists Endpoints across services' do
         s1 = Fabricate(:service, app: app)

data/spec/aptible/cli/subcommands/services_spec.rb

@@ -8,45 +8,162 @@ describe Aptible::CLI::Agent do
     allow(subject).to receive(:fetch_token) { token }
     allow(Aptible::Api::App).to receive(:all).with(token: token)
       .and_return([app])
-    allow(subject).to receive(:options).and_return(app: app.handle)
   end
 
-  it 'lists a CMD service' do
-    Fabricate(:service, app: app, process_type: 'cmd', command: nil)
-    subject.send('services')
+  describe '#services' do
+    before do
+      allow(subject).to receive(:options).and_return(app: app.handle)
+    end
 
-    expect(captured_output_text.split("\n")).to include('Service: cmd')
-    expect(captured_output_text.split("\n")).to include('Command: CMD')
-  end
+    it 'lists a CMD service' do
+      Fabricate(:service, app: app, process_type: 'cmd', command: nil)
+      subject.send('services')
+
+      expect(captured_output_text.split("\n")).to include('Service: cmd')
+      expect(captured_output_text.split("\n")).to include('Command: CMD')
+    end
+
+    it 'lists a service with command' do
+      Fabricate(:service, app: app, process_type: 'cmd', command: 'foobar')
+      subject.send('services')
+
+      expect(captured_output_text.split("\n")).to include('Service: cmd')
+      expect(captured_output_text.split("\n")).to include('Command: foobar')
+    end
+
+    it 'lists container size' do
+      Fabricate(:service, app: app, container_memory_limit_mb: 1024)
+      subject.send('services')
+
+      expect(captured_output_text.split("\n"))
+        .to include('Container Size: 1024')
+    end
+
+    it 'lists container count' do
+      Fabricate(:service, app: app, container_count: 3)
+      subject.send('services')
 
-  it 'lists a service with command' do
-    Fabricate(:service, app: app, process_type: 'cmd', command: 'foobar')
-    subject.send('services')
+      expect(captured_output_text.split("\n")).to include('Container Count: 3')
+    end
 
-    expect(captured_output_text.split("\n")).to include('Service: cmd')
-    expect(captured_output_text.split("\n")).to include('Command: foobar')
+    it 'lists multiple services' do
+      Fabricate(:service, app: app, process_type: 'foo')
+      Fabricate(:service, app: app, process_type: 'bar')
+      subject.send('services')
+
+      expect(captured_output_text.split("\n")).to include('Service: foo')
+      expect(captured_output_text.split("\n")).to include('Service: bar')
+    end
   end
 
-  it 'lists container size' do
-    Fabricate(:service, app: app, container_memory_limit_mb: 1024)
-    subject.send('services')
+  describe '#services:settings' do
+    let(:base_options) { { app: app.handle } }
+
+    it 'allows changing zero_downtime_deployment settings' do
+      stub_options(force_zero_downtime: true, simple_health_check: true)
+      service = Fabricate(:service, app: app, process_type: 'foo')
+
+      expect(service).to receive(:update!)
+        .with(force_zero_downtime: true, naive_health_check: true)
+
+      subject.send('services:settings', 'foo')
+    end
+
+    it 'allows changing only one of the options' do
+      stub_options(simple_health_check: true)
+      service = Fabricate(:service, app: app, process_type: 'foo')
+
+      expect(service).to receive(:update!).with(naive_health_check: true)
 
-    expect(captured_output_text.split("\n")).to include('Container Size: 1024')
+      subject.send('services:settings', 'foo')
+    end
   end
 
-  it 'lists container count' do
-    Fabricate(:service, app: app, container_count: 3)
-    subject.send('services')
+  describe '#services:sizing_policy' do
+    let(:base_options) { { app: app.handle } }
 
-    expect(captured_output_text.split("\n")).to include('Container Count: 3')
+    it 'returns the sizing policy' do
+      stub_options
+      service = Fabricate(:service, app: app, process_type: 'foo')
+      sizing_policy = Fabricate(:service_sizing_policy)
+      expect(service).to receive(:service_sizing_policy)
+        .and_return(sizing_policy)
+
+      subject.send('services:sizing_policy', 'foo')
+
+      out = captured_output_text
+      expect(out).to match(/Autoscaling Type: vertical/i)
+      expect(out).to match(/Metric Lookback Seconds: 1800/i)
+      expect(out).to match(/Percentile: 99.0/i)
+      expect(out).to match(/Post Scale Up Cooldown Seconds: 60/i)
+      expect(out).to match(/Post Scale Down Cooldown Seconds: 300/i)
+      expect(out).to match(/Post Release Cooldown Seconds: 300/i)
+      expect(out).to match(/Mem Cpu Ratio R Threshold: 4/i)
+      expect(out).to match(/Mem Cpu Ratio C Threshold: 2/i)
+      expect(out).to match(/Mem Scale Up Threshold: 0.9/i)
+      expect(out).to match(/Mem Scale Down Threshold: 0.75/i)
+      expect(out).to match(/Minimum Memory: 2048/i)
+      expect(out).to match(/Maximum Memory:/i)
+      expect(out).to match(/Min Cpu Threshold: 0.4/i)
+      expect(out).to match(/Max Cpu Threshold: 0.9/i)
+      expect(out).to match(/Min Containers: 2/i)
+      expect(out).to match(/Max Containers: 5/i)
+      expect(out).to match(/Scale Up Step: 1/i)
+      expect(out).to match(/Scale Down Step: 1/i)
+    end
+
+    it 'raises an error if the environment has no policy' do
+      stub_options
+      service = Fabricate(:service, app: app, process_type: 'foo')
+      expect(service).to receive(:service_sizing_policy).and_return(nil)
+      expect { subject.send('services:sizing_policy', 'foo') }
+        .to raise_error(/does not have a service sizing policy set/)
+    end
   end
 
-  it 'lists multiple services' do
-    Fabricate(:service, app: app, process_type: 'foo')
-    Fabricate(:service, app: app, process_type: 'bar')
-    subject.send('services')
+  describe '#services:sizing_policy:set' do
+    let(:base_options) { { app: app.handle } }
+    let(:args) do
+      {
+        autoscaling_type: 'vertical',
+        mem_scale_down_threshold: 0.5,
+        scale_up_step: 2,
+        post_scale_down_cooldown_seconds: 3,
+        percentile: 93.2
+      }
+    end
+
+    it 'updates existing sizing policy' do
+      stub_options(**args)
+      service = Fabricate(:service, app: app, process_type: 'foo')
+      sizing_policy = double(sizing_policy)
+      expect(service).to receive(:service_sizing_policy)
+        .and_return(sizing_policy)
+
+      api_args = args.except(:autoscaling_type)
+      api_args[:autoscaling] = args[:autoscaling_type]
+
+      expect(sizing_policy).to receive(:update!)
+        .with(**api_args)
+
+      subject.send('services:sizing_policy:set', 'foo')
+    end
+
+    it 'creates a new sizing policy if necessary' do
+      stub_options(**args)
+      service = Fabricate(:service, app: app, process_type: 'foo')
+
+      api_args = args.except(:autoscaling_type)
+      api_args[:autoscaling] = args[:autoscaling_type]
+
+      expect(service).to receive(:create_service_sizing_policy!)
+        .with(**api_args)
+
+      subject.send('services:sizing_policy:set', 'foo')
+    end
+  end
 
-    expect(captured_output_text.split("\n")).to include('Service: foo')
-    expect(captured_output_text.split("\n")).to include('Service: bar')
+  def stub_options(**opts)
+    allow(subject).to receive(:options).and_return(base_options.merge(opts))
   end
 end

data/spec/fabricators/service_sizing_policy_fabricator.rb

@@ -0,0 +1,22 @@
+class StubServiceSizingPolicy < OpenStruct; end
+
+Fabricator(:service_sizing_policy, from: :stub_service_sizing_policy) do
+  autoscaling 'vertical'
+  metric_lookback_seconds 1800
+  percentile 99.0
+  post_scale_up_cooldown_seconds 60
+  post_scale_down_cooldown_seconds 300
+  post_release_cooldown_seconds 300
+  mem_cpu_ratio_r_threshold 4
+  mem_cpu_ratio_c_threshold 2
+  mem_scale_up_threshold 0.9
+  mem_scale_down_threshold 0.75
+  minimum_memory 2048
+  maximum_memory nil
+  min_cpu_threshold 0.4
+  max_cpu_threshold 0.9
+  min_containers 2
+  max_containers 5
+  scale_up_step 1
+  scale_down_step 1
+end