ecs-rails 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfe4933e3eb4620330076f2125af1d6cb0d618f06f52ebf7594e09bd96ee814d
-  data.tar.gz: 504edec780c9ac72495e47a62a9ba947a2cb5f5c54efe0168d4c97ae3983eb59
+  metadata.gz: 17f65165aa5cdd39910dbbd8c5fe33fa9efdbb35d84d997eeb2a614ee60d799e
+  data.tar.gz: f1e47bc8be3542a5bf9373772fc4e9c58bff9b407c01096dd5a428d8f4f151b5
 SHA512:
-  metadata.gz: 468eeaa07559226e3cb18e7445d4fe087823b5152efb1b2b436d12b21d351728931cfeba4ee90118a090c611495e2cdefce799f77b6c378224702c0913d6fcc8
-  data.tar.gz: 1830eaff6a0e8852e2b563efb5cace637eed17a5169fd63de2c960c5cbfa9bf9e7d484e75b9c96f581da091d2b037eda60db702e27de35d5fd4102778daec5db
+  metadata.gz: c89cb54ab55232008edd3f87065e9b343c3a0a145af97b828e4139d68b2f92fe799792f04d73854c23457c312f60d4c4072c7b47a05e98fcca1bb773866ea2d0
+  data.tar.gz: 85a65061e5a6cce28457471579e09bf3e4aabb47ef13f05130bb7d51f703982874a0e4e96555af038075595b72139b38513920635cbd3428f187462bd66b7a2c

data/README.md

@@ -9,6 +9,8 @@ This gem helps to get the correct cluster arn and task id so that you don't have
 ```bash
 ecs console
 ecs bash
+ecs logs
+ecs scale
 ```
 
 # Installation
@@ -25,7 +27,7 @@ gem install 'ecs-rails'
 
 # Configuration
 
-## Plain Ruby
+## environment variables
 
 Via environment variables:
 
@@ -36,18 +38,16 @@ export ENV['AWS_SECRET_ACCESS_KEY'] = 'your-secret-access-key'
 export ENV['CONTAINER_NAME'] = 'your-container-name'
 ```
 
-## Rails
+## AWS SSO
 
-```ruby
-# config/initializers/ecs-rails.rb
-EcsRails.aws_region = 'us-east-1'
-EcsRails.aws_access_key_id = ENV['AWS_ACCESS_KEY_ID']
-EcsRails.aws_secret_access_key = ENV['AWS_SECRET_ACCESS_KEY']
-EcsRails.container_name = 'webapp'
+```
+aws sso login
 ```
 
 # Usage
 
+## Console
+
 Connect to Rails console on a running Task.
 
 ```ruby
@@ -75,3 +75,67 @@ You can specify service name via -s option by giving a string included in servic
 ecs console -c prod -s app
 irb(main)>
 ```
+
+## Bash
+
+Connect to bash session on a running Task.
+
+```bash
+ecs bash -c prod -s app
+bash-4.2#
+```
+
+## Logs
+
+Tail CloudWatch logs for a service.
+
+```bash
+ecs logs -c prod -s app
+
+Fetching log group from task definition...
+Log group: webapp-app-log-group-prod-827a419
+Executing command: aws logs tail webapp-app-log-group-prod-827a419 --region us-east-1 --follow --format short
+```
+
+The logs command will:
+- Automatically discover the CloudWatch log group from your ECS task definition
+- Tail logs in real-time with `--follow` flag
+- Display logs in a short, readable format
+- Press Ctrl-C to exit
+
+## Scale
+
+View the current scaling status of a service (refreshes every 5 seconds):
+
+```bash
+ecs scale -c prod -s app
+
+Press Ctrl-C to exit
+
+Fetching service status... (refreshes every 5 seconds)
+
+Service: webapp-app-prod-7c7cad7
+Cluster: webapp-cluster-prod
+Status: ACTIVE
+
+Task counts:
+  Desired: 2
+  Running: 2
+  Pending: 0
+```
+
+Scale a service up or down by changing the desired task count:
+
+```bash
+ecs scale -c prod -s app --count 5
+
+Fetching service status...
+Current desired count: 2
+Scaling service 'webapp-app-prod-7c7cad7' to 5 tasks...
+✓ Service scaled successfully!
+New desired count: 5
+```
+
+The scale command will:
+- Without `--count`: Show the current status including desired, running, and pending task counts, refreshing every 5 seconds. Press Ctrl-C to exit.
+- With `--count`: Update the service's desired count to the specified number and confirm the operation

data/bin/ecs

@@ -21,6 +21,10 @@ OptionParser.new do |opts|
     options[:config_file] = c
   end
 
+  opts.on("--count COUNT", "Number of tasks to scale to. Ex: 'ecs scale -c prod -s app --count 3'") do |c|
+    options[:count] = c
+  end
+
 end.parse!
 
 command_keyword = ARGV[0]

data/lib/ecs-rails/command_factory.rb

@@ -1,10 +1,10 @@
 module EcsRails
   class CommandFactory
-
     def initialize(command_keyword, options = {})
       @command_keyword = command_keyword
       @cluster_name = options[:cluster]
       @service_name = options[:service]
+      @count = options[:count]
     end
 
     def command
@@ -13,6 +13,10 @@ module EcsRails
         EcsRails::Console.new(cluster_name, service_name)
       when 'bash'
         EcsRails::Bash.new(cluster_name, service_name)
+      when 'logs'
+        EcsRails::Logs.new(cluster_name, service_name)
+      when 'scale'
+        EcsRails::Scale.new(cluster_name, service_name, count)
       else
         EcsRails::NullCommand.new
       end
@@ -20,7 +24,6 @@ module EcsRails
 
     private
 
-      attr_reader :command_keyword, :cluster_name, :service_name
-
+    attr_reader :command_keyword, :cluster_name, :service_name, :count
   end
 end

data/lib/ecs-rails/logs.rb

@@ -0,0 +1,43 @@
+module EcsRails
+  class Logs < Command
+    def call
+      return full_command if test_mode?
+
+      puts "Executing command: #{full_command}"
+      system(full_command)
+    end
+
+    private
+
+    def full_command
+      @full_command ||= "aws logs tail #{log_group_name} --region #{region} --follow --format short"
+    end
+
+    def log_group_name
+      puts('Fetching log group from task definition...')
+
+      service_descriptions = client.describe_services(
+        cluster: selected_cluster,
+        services: [selected_service]
+      ).services
+
+      task_definition_arn = service_descriptions.first.task_definition
+
+      task_definition = client.describe_task_definition(
+        task_definition: task_definition_arn
+      ).task_definition
+
+      log_config = task_definition.container_definitions.find { |c| c.name == container_name }&.log_configuration
+
+      if log_config && log_config.log_driver == 'awslogs'
+        group_name = log_config.options['awslogs-group']
+        puts("Log group: #{group_name}")
+        group_name
+      else
+        puts('Warning: Could not find awslogs configuration, trying default /ecs/[service-name] format')
+        service_name_from_arn = selected_service.split('/').last
+        "/ecs/#{service_name_from_arn}"
+      end
+    end
+  end
+end

data/lib/ecs-rails/scale.rb

@@ -0,0 +1,94 @@
+module EcsRails
+  class Scale < Command
+    def initialize(cluster_name = nil, service_name = nil, count = nil)
+      super(cluster_name, service_name)
+      @count = count
+    end
+
+    def call
+      if count.nil?
+        show_status_loop
+      else
+        scale_service_once
+      end
+    end
+
+    private
+
+    attr_reader :count
+
+    def show_status_loop
+      puts "Press Ctrl-C to exit\n\n"
+
+      trap('INT') do
+        puts "\nExiting..."
+        exit 0
+      end
+
+      loop do
+        print "\033[2J\033[H"
+
+        puts "Fetching service status... (refreshes every 5 seconds)\n"
+
+        service_descriptions = client.describe_services(
+          cluster: selected_cluster,
+          services: [selected_service]
+        ).services
+
+        service = service_descriptions.first
+        service_name = service.service_name
+
+        display_status(service, service_name)
+
+        sleep 5
+      end
+    end
+
+    def scale_service_once
+      puts 'Fetching service status...'
+
+      service_descriptions = client.describe_services(
+        cluster: selected_cluster,
+        services: [selected_service]
+      ).services
+
+      service = service_descriptions.first
+      service_name = service.service_name
+      current_count = service.desired_count
+
+      puts "Current desired count: #{current_count}"
+      puts "Scaling service '#{service_name}' to #{count} tasks..."
+
+      response = client.update_service(
+        cluster: selected_cluster,
+        service: selected_service,
+        desired_count: count.to_i
+      )
+
+      new_count = response.service.desired_count
+      puts '✓ Service scaled successfully!'
+      puts "New desired count: #{new_count}"
+    end
+
+    def display_status(service, service_name)
+      puts "\nService: #{service_name}"
+      puts "Cluster: #{service.cluster_arn.split('/').last}"
+      puts "Status: #{service.status}"
+      puts "\nTask counts:"
+      puts "  Desired: #{service.desired_count}"
+      puts "  Running: #{service.running_count}"
+      puts "  Pending: #{service.pending_count}"
+
+      return unless service.deployments.length > 1
+
+      puts "\nDeployments:"
+      service.deployments.each_with_index do |deployment, index|
+        status_label = deployment.rollout_state == 'COMPLETED' ? '(primary)' : '(in progress)'
+        puts "  #{index + 1}. #{status_label}"
+        puts "     Desired: #{deployment.desired_count}"
+        puts "     Running: #{deployment.running_count}"
+        puts "     Pending: #{deployment.pending_count}"
+      end
+    end
+  end
+end

data/lib/ecs-rails/task_selector.rb

@@ -1,6 +1,5 @@
 module EcsRails
   class TaskSelector
-
     def initialize(client, cluster_name, service_name)
       @client = client
       @cluster_name = cluster_name
@@ -13,7 +12,8 @@ module EcsRails
 
       service_descriptions.each do |service|
         service.deployments.each do |deployment|
-          task_arns = client.list_tasks(cluster: cluster_name, service_name: service.service_name, desired_status: 'RUNNING').task_arns
+          task_arns = client.list_tasks(cluster: cluster_name, service_name: service.service_name,
+                                        desired_status: 'RUNNING').task_arns
           next if task_arns.empty?
 
           tasks = client.describe_tasks(cluster: cluster_name, tasks: task_arns).tasks
@@ -22,12 +22,12 @@ module EcsRails
           tasks_for_deployment = tasks.select { |task| task.task_definition_arn == deployment.task_definition }
 
           if tasks_for_deployment.empty?
-            puts("      No tasks found for this deployment.")
+            puts('      No tasks found for this deployment.')
           elsif tasks_for_deployment.size == 1
             puts("      Task: #{task_arns.first}")
-              return task_arns.first
+            return task_arns.first
           else
-            ask_for_task(tasks_for_deployment)
+            return ask_for_task(tasks_for_deployment)
           end
         end
       end
@@ -35,13 +35,13 @@ module EcsRails
 
     private
 
-      attr_reader :client, :cluster_name, :service_name
+    attr_reader :client, :cluster_name, :service_name
 
-      def ask_for_task(tasks)
-        prompt = TTY::Prompt.new
-        choices = tasks.map { |task| task.split('/').last }
-        choice = prompt.enum_select("Select a task:", choices)
-        tasks.grep(Regexp.new(choice)).first
-      end
+    def ask_for_task(tasks)
+      prompt = TTY::Prompt.new
+      choices = tasks.map { |task| task.task_arn.split('/').last }
+      choice = prompt.enum_select('Select a task:', choices)
+      tasks.find { |task| task.task_arn.include?(choice) }.task_arn
+    end
   end
 end

data/lib/ecs-rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EcsRails
-  VERSION = '0.0.5'
+  VERSION = '0.0.7'
 end

data/lib/ecs-rails.rb

@@ -22,21 +22,21 @@ require_relative 'ecs-rails/command_factory'
 require_relative 'ecs-rails/command'
 require_relative 'ecs-rails/console'
 require_relative 'ecs-rails/bash'
+require_relative 'ecs-rails/logs'
+require_relative 'ecs-rails/scale'
 require_relative 'ecs-rails/null_command'
 
 # delegate
 require 'active_support/core_ext/module/delegation'
 
 # prompt
-require "tty-prompt"
+require 'tty-prompt'
 
 module EcsRails
-
   class << self
     def config
       EcsRails::EcsRailsConfiguration.instance
     end
     delegate(*EcsRails::EcsRailsConfiguration.delegated, to: :config)
   end
-
 end

data/spec/ecs-rails/task_selector_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+RSpec.describe EcsRails::TaskSelector do
+  let(:client) { instance_double(Aws::ECS::Client) }
+  let(:cluster_name) { 'test-cluster' }
+  let(:service_name) { 'test-service' }
+  let(:selector) { described_class.new(client, cluster_name, service_name) }
+
+  describe '#call' do
+    let(:service) { instance_double(Aws::ECS::Types::Service, service_name: service_name, deployments: [deployment]) }
+    let(:deployment) { instance_double(Aws::ECS::Types::Deployment, task_definition: 'task-def-arn') }
+    let(:task_arn) { 'arn:aws:ecs:us-east-1:123456789:task/cluster/abc123' }
+
+    before do
+      allow(client).to receive(:describe_services)
+        .with(cluster: cluster_name, services: [service_name])
+        .and_return(instance_double(Aws::ECS::Types::DescribeServicesResponse, services: [service]))
+    end
+
+    context 'when there are no running tasks' do
+      before do
+        allow(client).to receive(:list_tasks)
+          .with(cluster: cluster_name, service_name: service_name, desired_status: 'RUNNING')
+          .and_return(instance_double(Aws::ECS::Types::ListTasksResponse, task_arns: []))
+      end
+
+      it 'does not return a task ARN' do
+        result = selector.call
+        expect(result).not_to be_a(String)
+      end
+    end
+
+    context 'when there is one running task' do
+      let(:task) { instance_double(Aws::ECS::Types::Task, task_definition_arn: 'task-def-arn', task_arn: task_arn) }
+
+      before do
+        allow(client).to receive(:list_tasks)
+          .with(cluster: cluster_name, service_name: service_name, desired_status: 'RUNNING')
+          .and_return(instance_double(Aws::ECS::Types::ListTasksResponse, task_arns: [task_arn]))
+
+        allow(client).to receive(:describe_tasks)
+          .with(cluster: cluster_name, tasks: [task_arn])
+          .and_return(instance_double(Aws::ECS::Types::DescribeTasksResponse, tasks: [task]))
+      end
+
+      it 'returns the task ARN' do
+        expect(selector.call).to eq(task_arn)
+      end
+    end
+
+    context 'when there are multiple running tasks' do
+      let(:task_arn_1) { 'arn:aws:ecs:us-east-1:123456789:task/cluster/abc123' }
+      let(:task_arn_2) { 'arn:aws:ecs:us-east-1:123456789:task/cluster/def456' }
+      let(:task_1) { instance_double(Aws::ECS::Types::Task, task_definition_arn: 'task-def-arn', task_arn: task_arn_1) }
+      let(:task_2) { instance_double(Aws::ECS::Types::Task, task_definition_arn: 'task-def-arn', task_arn: task_arn_2) }
+      let(:prompt) { instance_double(TTY::Prompt) }
+
+      before do
+        allow(client).to receive(:list_tasks)
+          .with(cluster: cluster_name, service_name: service_name, desired_status: 'RUNNING')
+          .and_return(instance_double(Aws::ECS::Types::ListTasksResponse, task_arns: [task_arn_1, task_arn_2]))
+
+        allow(client).to receive(:describe_tasks)
+          .with(cluster: cluster_name, tasks: [task_arn_1, task_arn_2])
+          .and_return(instance_double(Aws::ECS::Types::DescribeTasksResponse, tasks: [task_1, task_2]))
+
+        allow(TTY::Prompt).to receive(:new).and_return(prompt)
+        allow(prompt).to receive(:enum_select).with('Select a task:', %w[abc123 def456]).and_return('abc123')
+      end
+
+      it 'prompts the user to select a task and returns the selected task ARN' do
+        expect(selector.call).to eq(task_arn_1)
+      end
+    end
+
+    context 'when tasks do not match the deployment task definition' do
+      let(:task_arn) { 'arn:aws:ecs:us-east-1:123456789:task/cluster/abc123' }
+      let(:task) { instance_double(Aws::ECS::Types::Task, task_definition_arn: 'different-task-def', task_arn: task_arn) }
+
+      before do
+        allow(client).to receive(:list_tasks)
+          .with(cluster: cluster_name, service_name: service_name, desired_status: 'RUNNING')
+          .and_return(instance_double(Aws::ECS::Types::ListTasksResponse, task_arns: [task_arn]))
+
+        allow(client).to receive(:describe_tasks)
+          .with(cluster: cluster_name, tasks: [task_arn])
+          .and_return(instance_double(Aws::ECS::Types::DescribeTasksResponse, tasks: [task]))
+      end
+
+      it 'does not return a task ARN' do
+        result = selector.call
+        expect(result).not_to be_a(String)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ecs-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Franck D'agostini
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-16 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -140,18 +139,20 @@ files:
 - lib/ecs-rails/command_factory.rb
 - lib/ecs-rails/console.rb
 - lib/ecs-rails/ecs_rails_configuration.rb
+- lib/ecs-rails/logs.rb
 - lib/ecs-rails/null_command.rb
+- lib/ecs-rails/scale.rb
 - lib/ecs-rails/service_selector.rb
 - lib/ecs-rails/task_selector.rb
 - lib/ecs-rails/version.rb
 - spec/ecs-rails/ecs_rails_configuration_spec.rb
+- spec/ecs-rails/task_selector_spec.rb
 - spec/fixtures/ecs-rails.yml
 - spec/spec_helper.rb
 homepage: https://rubygems.org/gems/ecs-rails
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -166,8 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Connect to your AWS ECS tasks
 test_files: []