hibernate 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1e5b683d653f45c6747b92d58f5bc5258111837bec3eec25945c0e8b58de37f
-  data.tar.gz: acb1ea6c6401883e116ee44da22f5179ff3009424fc90ff3d5f5db5e650470c3
+  metadata.gz: 21e7dde6cd66464fa7aff8bc01d5f1338e65ba5f180d27c6d7fc176fcf9dbff5
+  data.tar.gz: 84a9f6eb6fd06373cbe68b686048107636cb2821eee5284b9a408062378e05f8
 SHA512:
-  metadata.gz: 0b96aa6e000fbe289ea668497918d6352103e398560e112e20898ff9a2b65583340e132e369b308990eaeede6a954c951ea9bf52a1f8947a8307336abe29a18e
-  data.tar.gz: 92c1af50b90c66fe7ee91101e37ae76ca6abb63e2e5fb1671adc1fbfcf2d9f904b0dced62b999b1bbd3a09c48b43ee02d8cbd625c29ddcd2e8ca25e2935dac54
+  metadata.gz: 250624e8f6984ca9cee0685c8d99a990e6fb45c66a88a16a9fd1bc68f430d252c1377d55ca31f1b95806250748e1b8be683fef73f374e1dc708bbba77b65f8e0
+  data.tar.gz: 5495ddec8a33acf9c2b4a8eeb8026f762d8f37716912bb238d6c797587403e62f0bb8023202d1755b522f6e09292146bc298e97e1bd335febed73124d54a7658

data/bin/hibernate

@@ -4,42 +4,68 @@ require 'optparse'
 require_relative '../lib/hibernate/lambda_setup'
 require_relative '../lib/hibernate/ec2_manager'
 
-# Define the command-line interface
 class HibernateCLI
   def self.run
     command = nil
     options = {}
 
+    if ARGV.include?('setup')
+      command = :setup
+      ARGV.delete('setup')
+    elsif ARGV.include?('rule')
+      command = :manage_ec2
+      ARGV.delete('rule')
+    end
+
     parser = OptionParser.new do |parser|
       parser.banner = "Usage: hibernate [command] [options]"
 
-      # Command for setting up the Lambda function
-      parser.on('setup', 'Create the Lambda function') do
-        command = :setup
+      parser.on('--instance-name=<INSTANCE_NAME>', 'Specify the EC2 instance name') do |instance_name|
+        options[:instance_name] = instance_name
       end
 
-      # Command for managing EC2 instances
-      parser.on('node', 'Manage EC2 instances') do
-        command = :manage_ec2
+      parser.on('--start-expression=<START_CRON>', 'Specify the cron expression to start the instance') do |start_cron|
+        options[:start_cron] = start_cron
       end
 
-      # Options for the EC2 management command
-      parser.on('--in=<INSTANCE_NAME>', 'Specify the EC2 instance name') do |instance_name|
-        options[:instance_name] = instance_name
+      parser.on('--stop-expression=<STOP_CRON>', 'Specify the cron expression to stop the instance') do |stop_cron|
+        options[:stop_cron] = stop_cron
       end
 
-      parser.on('--start_instance=<START_CRON>', 'Specify the cron expression to start the instance') do |start_cron|
-        options[:start_cron] = start_cron
+      parser.on('--start-instance=<true/false>', 'Filter start rules') do |start_instance|
+        options[:start_instance] = start_instance == 'true'
       end
 
-      parser.on('--stop_instance=<STOP_CRON>', 'Specify the cron expression to stop the instance') do |stop_cron|
-        options[:stop_cron] = stop_cron
+      parser.on('--stop-instance=<true/false>', 'Filter stop rules') do |stop_instance|
+        options[:stop_instance] = stop_instance == 'true'
+      end
+
+      parser.on('--rule-name=<RULE Name>', 'Specify the rule name to remove or update') do |rule_name|
+        options[:rule_name] = rule_name
+      end
+
+      parser.on('--update', 'Update an existing rule') do
+        options[:update] = true
+      end
+
+      parser.on('--remove', 'Remove an existing rule') do
+        options[:remove] = true
+      end
+
+      parser.on('--create', 'Create a new rule') do
+        options[:create] = true
+      end
+
+      parser.on('--list', 'List rules') do
+        options[:list] = true
+      end
+
+      parser.on('--state=<enable/disable>', 'Set rule state to either enable or disable') do |state|
+        options[:state] = state
       end
     end
 
-    # Parse the command-line arguments
     begin
-      p ARGV  # Debug: Print the command-line arguments
       parser.parse!(ARGV)
     rescue OptionParser::ParseError => e
       puts e.message
@@ -47,7 +73,6 @@ class HibernateCLI
       exit 1
     end
 
-    # Ensure only one command is processed
     if command.nil?
       puts "Please provide a command."
       puts parser
@@ -58,27 +83,68 @@ class HibernateCLI
     when :setup
       create_lambda_function
     when :manage_ec2
-      # Validate EC2 management command options
-      if options[:instance_name].nil? || options[:start_cron].nil? || options[:stop_cron].nil?
-        puts "Please provide the instance name, start cron expression, and stop cron expression."
-        puts parser
-        exit
-      else
-        manage_ec2(options[:instance_name], options[:start_cron], options[:stop_cron])
+      if options[:update]
+        update_ec2_rule_command(options)
+      elsif options[:remove]
+        remove_ec2_rule_command(options)
+      elsif options[:create]
+        create_ec2_rule_command(options)
+      elsif options[:list]
+        list_ec2_rule_command(options)
       end
     end
   end
 
   def self.create_lambda_function
-    p "I am printed here in setup"
     LambdaSetup.new.run
   end
 
-  def self.manage_ec2(instance_name, start_cron, stop_cron)
-    p "I am printed here inside node"
-    ec2_manager = EC2Manager.new(instance_name, start_cron, stop_cron)
-    ec2_manager.create_event_rule
+  def self.create_ec2_rule_command(options)
+    if options[:instance_name].nil? || (options[:start_cron].nil? && options[:stop_cron].nil?)
+      puts "Please provide the instance name, and at least one cron expression (start or stop)."
+      puts "Usage: hibernate rule --create --instance-name=<INSTANCE_NAME> --start-expression=<START_CRON> --stop-expression=<STOP_CRON>"
+      exit
+    else
+      ec2_manager = EC2Manager.new(options[:instance_name])
+      ec2_manager.create_event_rule(options[:start_cron], options[:stop_cron])
+    end
+  end
+
+  def self.remove_ec2_rule_command(options)
+    if options[:rule_name].nil?
+      puts "Please provide the rule name to remove."
+      puts "Usage: hibernate rule --remove --rule-name=<RULE NAME>"
+      exit
+    else
+      ec2_manager = EC2Manager.new(options[:instance_name])
+      ec2_manager.remove_event_rule(options[:rule_name])
+    end
+  end
+
+  def self.list_ec2_rule_command(options)
+    ec2_manager = EC2Manager.new(options[:instance_name])
+    ec2_manager.list_event_rules(options)
+  end
+
+  def self.update_ec2_rule_command(options)
+    if options[:rule_name].nil?
+      puts "Please provide the rule name to update."
+      puts "Usage: hibernate rule --update --rule-name=<RULE_NAME> [--start-expression=<START_CRON>] [--stop-expression=<STOP_CRON>] [--state=<enable/disable>]"
+      exit
+    elsif options[:start_cron].nil? && options[:stop_cron].nil? && options[:state].nil?
+      puts "Please provide atleast one attribute to update."
+      puts "Usage: hibernate rule --update --rule-name=<RULE_NAME> [--start-expression=<START_CRON>] [--stop-expression=<STOP_CRON>] [--state=<enable/disable>]"
+      exit
+    else
+      ec2_manager = EC2Manager.new(options[:instance_name])
+      ec2_manager.update_event_rule(
+        rule_name: options[:rule_name],
+        start_cron: options[:start_cron],
+        stop_cron: options[:stop_cron],
+        state: options[:state]
+      )
+    end
   end
 end
 
-HibernateCLI.run
+HibernateCLI.run

data/lib/hibernate/cloud_watch_event_manager.rb

@@ -0,0 +1,232 @@
+require 'aws-sdk-cloudwatchevents'
+require 'json'
+require 'dotenv/load'
+require 'digest'
+
+class CloudWatchEventManager
+  def initialize(events_client, instance_id = nil, instance_name = nil, lambda_function_arn)
+    @events_client = events_client
+    @instance_id = instance_id
+    @instance_name = instance_name
+    @lambda_function_arn = lambda_function_arn
+    @aws_region = ENV['AWS_REGION']
+    @account_id = ENV['ACCOUNT_ID']
+    @lambda_client = Aws::Lambda::Client.new(region: @aws_region)
+  end
+
+  attr_writer :instance_id, :instance_name
+
+  def create_start_rule(cron_expression)
+    rule_name = "StartInstanceRule-#{@instance_id}-#{cron_expression_hash(cron_expression)}"
+    create_rule(
+      rule_name,
+      cron_expression,
+      { instance_id: @instance_id, action: 'start' },
+      'start'
+    )
+  end
+
+  def create_stop_rule(cron_expression)
+    rule_name = "StopInstanceRule-#{@instance_id}-#{cron_expression_hash(cron_expression)}"
+    create_rule(
+      rule_name,
+      cron_expression,
+      { instance_id: @instance_id, action: 'stop' },
+      'stop'
+    )
+  end
+
+  def remove_rule(rule_name)
+    remove_rule_by_name(rule_name)
+    remove_lambda_permission(rule_name)
+  end
+
+  def list_event_rules(options)
+    next_token = nil
+
+    column_widths = {
+      rule_name: 40,
+      instance_id: 22,
+      schedule: 30,
+      state: 10,
+      action: 10
+    }
+
+    print_header(column_widths)
+
+    loop do
+      response = @events_client.list_rules(next_token: next_token)
+
+      response.rules.each do |rule|
+        process_rule(rule, options, column_widths)
+      end
+
+      next_token = response.next_token
+      break if next_token.nil?
+    end
+
+    print_footer(column_widths)
+  end
+
+  def update_rule_state(rule_name, state)
+    state = state == 'enable' ? 'ENABLED' : 'DISABLED'
+
+    rule_details = @events_client.describe_rule({ name: rule_name })
+
+    params = {
+      name: rule_name,
+      state: state,
+      description: rule_details.description
+    }
+
+    if rule_details.schedule_expression
+      params[:schedule_expression] = rule_details.schedule_expression
+    elsif rule_details.event_pattern
+      params[:event_pattern] = rule_details.event_pattern
+    else
+      puts "No ScheduleExpression or EventPattern found for rule '#{rule_name}'."
+      exit 1
+    end
+  
+    @events_client.put_rule(params)
+  end
+
+  def get_instance_id_from_rule(rule_name)
+    response = @events_client.list_targets_by_rule({ rule: rule_name })
+    return nil if response.targets.empty?
+
+    target_input = response.targets[0].input
+    parsed_input = JSON.parse(target_input)
+    parsed_input['instance_id'] if parsed_input.key?('instance_id')
+  rescue Aws::CloudWatchEvents::Errors::ResourceNotFoundException => e
+    puts "Error fetching targets for rule: #{rule_name} - #{e.message}"
+    nil
+  end
+
+  def rule_exists?(rule_name)
+    begin
+      response = @events_client.describe_rule({ name: rule_name })
+      return true unless response.nil?
+    rescue Aws::CloudWatchEvents::Errors::ResourceNotFoundException
+      return false
+    end
+  end
+
+  private
+
+  def cron_expression_hash(cron_expression)
+    Digest::SHA256.hexdigest(cron_expression)[0..7] 
+  end
+
+  def create_rule(rule_name, cron_expression, input_data, action)
+    @events_client.put_rule({
+      name: rule_name,
+      schedule_expression: "cron(#{cron_expression})",
+      state: 'ENABLED',
+      description: "Rule to #{action} EC2 instance #{@instance_id} (Name: #{@instance_name}) at specified time: cron(#{cron_expression})",
+    })
+
+    add_lambda_permission(rule_name)
+
+    @events_client.put_targets({
+      rule: rule_name,
+      targets: [
+        {
+          id: '1',
+          arn: @lambda_function_arn,
+          input: input_data.to_json,
+        },
+      ],
+    })
+
+    puts "#{action.capitalize} rule created for instance '#{@instance_name}' (ID: #{@instance_id})."
+  end
+
+  def add_lambda_permission(rule_name)
+    begin
+      @lambda_client.add_permission({
+        function_name: @lambda_function_arn,
+        statement_id: "#{rule_name}-Permission",
+        action: "lambda:InvokeFunction",
+        principal: "events.amazonaws.com",
+        source_arn: "arn:aws:events:#{@aws_region}:#{@account_id}:rule/#{rule_name}"
+      })
+
+      puts "Permission added for rule #{rule_name} to invoke Lambda #{@lambda_function_arn}."
+    rescue Aws::Lambda::Errors::ResourceConflictException => e
+      puts "Permission already exists: #{e.message}"
+    end
+  end
+
+  def remove_rule_by_name(rule_name)
+    @events_client.remove_targets({
+      rule: rule_name,
+      ids: ['1']
+    })
+    @events_client.delete_rule({
+      name: rule_name
+    })
+
+    puts "Removed rule '#{rule_name}'"
+  end
+
+  def remove_lambda_permission(rule_name)
+    begin
+      @lambda_client.remove_permission({
+        function_name: @lambda_function_arn,
+        statement_id: "#{rule_name}-Permission"
+      })
+      puts "Removed Lambda permission for rule '#{rule_name}' to invoke Lambda #{@lambda_function_arn}."
+    rescue Aws::Lambda::Errors::ResourceNotFoundException => e
+      puts "Permission not found: #{e.message}"
+    end
+  end
+
+  def print_header(column_widths)
+    total_width = column_widths.values.sum + 8
+    puts "-" * total_width
+    puts "| #{'Rule Name'.ljust(column_widths[:rule_name])} | " \
+         "#{ 'Instance ID'.ljust(column_widths[:instance_id])} | " \
+         "#{ 'Schedule (UTC)'.ljust(column_widths[:schedule])} | " \
+         "#{ 'State'.ljust(column_widths[:state])} | " \
+         "#{ 'Action'.ljust(column_widths[:action])} |"
+    puts "-" * total_width
+  end
+
+  def print_footer(column_widths)
+    total_width = column_widths.values.sum + 8
+    puts '-' * total_width
+  end
+
+  def process_rule(rule, options, column_widths)
+    targets = @events_client.list_targets_by_rule(rule: rule.name).targets
+    target = targets.find { |t| t.arn == @lambda_function_arn }
+
+    return unless target
+
+    input = JSON.parse(target.input)
+    action = input['action']
+    rule_instance_id = input['instance_id']
+
+    if matches_criteria?(rule_instance_id, action, options)
+      print_rule(rule, rule_instance_id, action, column_widths)
+    end
+  end
+
+  def matches_criteria?(rule_instance_id, action, options)
+    instance_id_match = options[:instance_id].nil? || options[:instance_id] == rule_instance_id
+    action_match = (options[:start_instance] && action == 'start') ||
+                   (options[:stop_instance] && action == 'stop') ||
+                   (options[:start_instance].nil? && options[:stop_instance].nil?)
+
+    instance_id_match && action_match
+  end
+
+  def print_rule(rule, rule_instance_id, action, column_widths)
+    puts "| #{rule.name.ljust(column_widths[:rule_name])} | " \
+         "#{rule_instance_id.ljust(column_widths[:instance_id])} | " \
+         "#{rule.schedule_expression.ljust(column_widths[:schedule])} | " \
+         "#{rule.state.ljust(column_widths[:state])} | " \
+         "#{action.capitalize.ljust(column_widths[:action])} |"
+  end
+end

data/lib/hibernate/ec2_manager.rb

@@ -1,23 +1,26 @@
 require 'aws-sdk-ec2'
-require 'aws-sdk-cloudwatchevents'
 require 'dotenv/load'
 require 'json'
+require_relative 'cloud_watch_event_manager' # Adjust the path to where the new class is located
 
 class EC2Manager
-  def initialize(instance_name, start_cron, stop_cron)
+  def initialize(instance_name = nil)
     @instance_name = instance_name
-    @start_cron = start_cron
-    @stop_cron = stop_cron
     @aws_region = ENV['AWS_REGION']
     @account_id = ENV['ACCOUNT_ID']
-    
+
     @ec2_client = Aws::EC2::Client.new(region: @aws_region)
     @events_client = Aws::CloudWatchEvents::Client.new(region: @aws_region)
-    
+
     @lambda_function_name = "ec2_auto_shutdown_start_function"
-    @instance_id = get_instance_id_by_name
+    @lambda_function_arn = construct_lambda_function_arn
+    @instance_id = get_instance_id_by_name unless @instance_name.nil?
+
+    @cloudwatch_event_manager = CloudWatchEventManager.new(@events_client, @instance_id, @instance_name, @lambda_function_arn)
   end
 
+  attr_writer :instance_name, :instance_id
+
   def get_instance_id_by_name
     response = @ec2_client.describe_instances({
       filters: [
@@ -36,59 +39,80 @@ class EC2Manager
     instance_id
   end
 
-  def create_event_rule
-    create_start_rule
-    create_stop_rule
+  def create_event_rule(start_cron, stop_cron)
+    @cloudwatch_event_manager.create_start_rule(start_cron) unless start_cron.nil?
+    @cloudwatch_event_manager.create_stop_rule(stop_cron) unless stop_cron.nil?
     puts "CloudWatch Events created for instance '#{@instance_name}' (ID: #{@instance_id})."
   end
 
-  private
+  def remove_event_rule(rule_name)
+    @cloudwatch_event_manager.remove_rule(rule_name)
+    puts "CloudWatch Events removed for rule: #{rule_name}."
+  end
 
-  def create_start_rule
-    lambda_function_arn = construct_lambda_function_arn
+  def list_event_rules(options)
+    options[:instance_id] = @instance_id unless @instance_id.nil?
+    @cloudwatch_event_manager.list_event_rules(options)
+  end
 
-    @events_client.put_rule({
-      name: "StartInstanceRule-#{@instance_id}",
-      schedule_expression: "cron(#{@start_cron})",
-      state: 'ENABLED',
-      description: "Rule to start EC2 instance #{@instance_id} (Name: #{@instance_name}) at specified time",
-    })
+  def update_event_rule(rule_name:, start_cron:, stop_cron:, state:)
+    rule_exists = @cloudwatch_event_manager.rule_exists?(rule_name)
 
-    @events_client.put_targets({
-      rule: "StartInstanceRule-#{@instance_id}",
-      targets: [
-        {
-          id: '1',
-          arn: lambda_function_arn,
-          input: { instance_id: @instance_id, action: 'start' }.to_json,
-        },
-      ],
-    })
-  end
+    unless rule_exists
+      puts "Rule '#{rule_name}' does not exist."
+      exit 1
+    end
+
+    target_instance_id = @cloudwatch_event_manager.get_instance_id_from_rule(rule_name)
+    if target_instance_id.nil?
+      puts "No targets found for the rule '#{rule_name}'."
+      exit 1
+    end
 
-  def create_stop_rule
-    lambda_function_arn = construct_lambda_function_arn
+    instance_name = get_instance_name_by_id(target_instance_id)
 
-    @events_client.put_rule({
-      name: "StopInstanceRule-#{@instance_id}",
-      schedule_expression: "cron(#{@stop_cron})",
-      state: 'ENABLED',
-      description: "Rule to stop EC2 instance #{@instance_id} (Name: #{@instance_name}) at specified time",
-    })
+    @cloudwatch_event_manager.instance_id = target_instance_id
+    @cloudwatch_event_manager.instance_name = instance_name
 
-    @events_client.put_targets({
-      rule: "StopInstanceRule-#{@instance_id}",
-      targets: [
-        {
-          id: '1',
-          arn: lambda_function_arn,
-          input: { instance_id: @instance_id, action: 'stop' }.to_json,
-        },
-      ],
-    })
+    self.instance_id = target_instance_id
+    self.instance_name = instance_name
+
+    puts "Found instance ID: #{@instance_id} from the rule: #{rule_name}"
+
+    if start_cron || stop_cron
+      puts "Removing old rule: #{rule_name} as cron expression is being updated."
+      remove_event_rule(rule_name)
+
+      create_event_rule(start_cron, stop_cron)
+      puts "Created new rule with updated cron expression for instance '#{@instance_name}' (ID: #{@instance_id})."
+    end
+
+    return if state.nil?
+
+    @cloudwatch_event_manager.update_rule_state(rule_name, state)
+    puts "Rule '#{rule_name}' has been #{state == 'enable' ? 'enabled' : 'disabled'}."
   end
 
+  private
+
   def construct_lambda_function_arn
     "arn:aws:lambda:#{@aws_region}:#{@account_id}:function:#{@lambda_function_name}"
   end
-end
+
+  def get_instance_name_by_id(instance_id)
+    response = @ec2_client.describe_instances({
+      instance_ids: [instance_id]
+    })
+
+    if response.reservations.empty?
+      puts "No instance found with ID '#{instance_id}'."
+      return nil
+    end
+
+    instance = response.reservations[0].instances[0]
+    tags = instance.tags || []
+
+    name_tag = tags.find { |tag| tag.key == 'Name' }
+    name_tag&.value
+  end
+end

data/lib/hibernate/lambda_setup.rb

@@ -1,12 +1,13 @@
 require 'aws-sdk-lambda'
-require 'aws-sdk-iam'   # For creating the IAM role and policy
+require 'aws-sdk-iam'
 require 'zip'
-require 'dotenv/load'   # Automatically loads environment variables from .env
+require 'dotenv/load'
 require 'fileutils'
+require 'pry'
 
 class LambdaSetup
   def initialize
-    @lambda_role_name = "ec2-auto-shutdown-start"  # Define a unique role name
+    @lambda_role_name = "ec2-auto-shutdown-start"
     @lambda_handler = "ec2_auto_shutdown_start_function"
     @lambda_zip = "lambda_function.zip"
     @aws_region = ENV['AWS_REGION']
@@ -18,33 +19,34 @@ class LambdaSetup
     )
   end
 
-  # Function to zip the Lambda function code
   def create_zip_file(dir)
-    FileUtils.rm_f(@lambda_zip)  # Remove any existing zip file
+    FileUtils.rm_f(@lambda_zip)
 
     Zip::File.open(@lambda_zip, Zip::File::CREATE) do |zip|
-      Dir[File.join(dir, '**', '**')].each do |file|
-        zip.add(file.sub(dir + '/', ''), file)
+      Dir.glob(File.join('lib', 'hibernate',dir, '**', '*')).each do |file|
+        next if File.directory?(file)
+        zip_path = File.basename(file)
+        puts "Adding #{file} as #{zip_path}"
+        File.open(file, 'rb') do |io|
+          zip.add(zip_path, io)
+        end
       end
     end
 
     puts "ZIP file created: #{@lambda_zip}"
   end
 
-  # Function to check if an IAM role exists
   def iam_role_exists?(role_name)
     begin
       @iam_client.get_role(role_name: role_name)
-      true  # Role exists
+      true
     rescue Aws::IAM::Errors::NoSuchEntity
-      false  # Role does not exist
+      false
     end
   end
 
-  # Function to create the IAM role and policy
   def create_lambda_role
     unless iam_role_exists?(@lambda_role_name)
-      # Trust policy for Lambda service to assume this role
       trust_policy = {
         Version: "2012-10-17",
         Statement: [
@@ -58,14 +60,12 @@ class LambdaSetup
         ]
       }.to_json
 
-      # Create the IAM role
       puts "Creating IAM role..."
       @iam_client.create_role({
         role_name: @lambda_role_name,
         assume_role_policy_document: trust_policy
       })
 
-      # Define the custom policy for EC2 actions
       policy_document = {
         Version: "2012-10-17",
         Statement: [
@@ -81,7 +81,6 @@ class LambdaSetup
         ]
       }.to_json
 
-      # Attach custom policy to the IAM role
       puts "Attaching custom EC2 policy to IAM role..."
       @iam_client.put_role_policy({
         role_name: @lambda_role_name,
@@ -89,7 +88,6 @@ class LambdaSetup
         policy_document: policy_document
       })
 
-      # Attach basic execution role to allow CloudWatch logging
       @iam_client.attach_role_policy({
         role_name: @lambda_role_name,
         policy_arn: 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
@@ -101,39 +99,35 @@ class LambdaSetup
     end
   end
 
-  # Function to check if the Lambda function exists
   def lambda_function_exists?(function_name)
     begin
       @lambda_client.get_function(function_name: function_name)
-      true  # Lambda function exists
+      true
     rescue Aws::Lambda::Errors::ResourceNotFoundException
-      false  # Lambda function does not exist
+      false
     end
   end
 
-  # Function to create the Lambda function
   def create_lambda_function
     role_arn = @iam_client.get_role(role_name: @lambda_role_name).role.arn
 
     if lambda_function_exists?(@lambda_handler)
       puts "Lambda function '#{@lambda_handler}' already exists. Skipping creation."
     else
-      # Read the ZIP file as binary content
       zip_content = File.read(@lambda_zip)
 
-      # Create Lambda function
       begin
         puts "Creating Lambda function..."
         @lambda_client.create_function({
           function_name: @lambda_handler,
-          runtime: 'ruby3.2',  # Specify your desired runtime
-          role: role_arn,  # Use the ARN of the newly created role
+          runtime: 'ruby3.2',
+          role: role_arn,
           handler: "#{@lambda_handler}.lambda_handler",
           code: {
             zip_file: zip_content,
           },
           description: 'Lambda function to start and stop EC2 instances',
-          timeout: 30,
+          timeout: 30
         })
         puts "Lambda function created."
       rescue Aws::Lambda::Errors::ServiceError => e
@@ -142,10 +136,9 @@ class LambdaSetup
     end
   end
 
-  # Main method to execute the setup
   def run
-    create_zip_file('lambda_function')  # Pass the directory containing your Lambda function code
+    create_zip_file('lambda_function')
     create_lambda_role
     create_lambda_function
   end
-end
+end

data/lib/hibernate/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hibernate
-  VERSION = "0.1.0"
-end
+  VERSION = '0.1.3'
+end

data/lib/hibernate.rb

@@ -3,4 +3,8 @@ require 'aws-sdk-cloudwatch'
 require 'dotenv'
 require 'json'
 
-Dotenv.load
+Dotenv.load
+
+module Hibernate
+  require_relative 'hibernate/version'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hibernate
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.3
 platform: ruby
 authors:
-- Your Name
+- Manish Sharma
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-29 00:00:00.000000000 Z
+date: 2024-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-ec2
@@ -108,25 +108,28 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A Ruby gem to automate the management of EC2 instances using AWS Lambda.
+description: A Ruby gem to automate the shutdown and start of our EC2 instances
 email:
-- youremail@example.com
+- sharma.manish7575@gmail.com
 executables:
 - hibernate
 extensions: []
 extra_rdoc_files: []
 files:
-- Readme.md
 - bin/hibernate
 - lib/hibernate.rb
+- lib/hibernate/cloud_watch_event_manager.rb
 - lib/hibernate/ec2_manager.rb
-- lib/hibernate/lambda_function/function.rb
+- lib/hibernate/lambda_function/ec2_auto_shutdown_start_function.rb
 - lib/hibernate/lambda_setup.rb
 - lib/hibernate/version.rb
-homepage: https://github.com/yourusername/ec2_manager
+homepage: https://github.com/maniSHarma7575/hibernate
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/maniSHarma7575/hibernate
+  homepage_uri: https://github.com/maniSHarma7575/hibernate
+  bug_tracker_uri: https://github.com/maniSHarma7575/hibernate/issues
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -145,5 +148,5 @@ requirements: []
 rubygems_version: 3.5.1
 signing_key:
 specification_version: 4
-summary: Manage EC2 instances with Lambda functions
+summary: Automating the shutdown and start of our EC2 instances
 test_files: []