opsicle 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 28e633711e529c0fbd1aa244ad2d91737f0bfc2c
-  data.tar.gz: 8327ed68f3943024ebda08aa1d46cd25edd26cc0
+  metadata.gz: ec2a91363560aea651074f4c23361278855ce22d
+  data.tar.gz: c55b4b23ebab64601cc4f211bc2dbb27380bd3af
 SHA512:
-  metadata.gz: 6e8f8d045efe127e29a74f187388be4a2c715b63c49e33198f23aefbd4ea3ec4dd887d4a74c27de893d6ebc928b207f5da916dd85a283365de803cabfa4831d0
-  data.tar.gz: c9d394a670b3eba259d0a4bff78b72906a8101b1f622da52d0efb060cc084eeefb143fbe0fe4bf483a6ceef45d15bd64b3fe83825917a5752a8b685090451616
+  metadata.gz: 4b214985df18e366ad1e93d2a649a7809e1e2c033e59de932caad7067e56700702428159ec807da4283072b6dfe0165d13244f486e9d17a5347f24f62e50ca52
+  data.tar.gz: f92adf09b8751466df7d5281dcd2e165ed59f7389cbe266079dafd79f4341c0da1faea4ac8709b0e19aee795a2d24e44f4f01627ac2ea0b0bd84906aa46aad1b

data/bin/opsicle

@@ -193,6 +193,15 @@ command 'execute-recipes' do |c|
   end
 end
 
+desc "Clone instances in the given environment stack"
+arg_name '<environment>'
+command 'clone-instance' do |c|
+  c.action do |global_options, options, args|
+    raise ArgumentError, "Environment is required" unless args.first
+    Opsicle::CloneInstance.new(args.first).execute global_options.merge options
+  end
+end
+
 desc "List all instances in the given environment stack"
 arg_name '<environment>'
 command :instances do |c|

data/lib/opsicle/cloneable_instance.rb

@@ -0,0 +1,94 @@
+module Opsicle
+  class CloneableInstance
+    attr_accessor :hostname, :status, :layer, :ami_id, :instance_type, :agent_version, :stack_id, :layer_ids,
+                  :auto_scaling_type, :os, :ssh_key_name, :availability_zone, :virtualization_type, :subnet_id,
+                  :architecture, :root_device_type, :install_updates_on_boot, :ebs_optimized, :tenancy, :opsworks, :cli
+
+    def initialize(instance, layer, opsworks, cli)
+      self.hostname = instance.hostname
+      self.status = instance.status
+      self.layer = layer
+      self.ami_id = instance.ami_id
+      self.instance_type = instance.instance_type
+      self.agent_version = instance.agent_version
+      self.stack_id = instance.stack_id
+      self.layer_ids = instance.layer_ids
+      self.auto_scaling_type = instance.auto_scaling_type
+      self.os = instance.os
+      self.ssh_key_name = instance.ssh_key_name
+      self.availability_zone = instance.availability_zone
+      self.virtualization_type = instance.virtualization_type
+      self.subnet_id = instance.subnet_id
+      self.architecture = instance.architecture
+      self.root_device_type = instance.root_device_type
+      self.install_updates_on_boot = instance.install_updates_on_boot
+      self.ebs_optimized = instance.ebs_optimized
+      self.tenancy = instance.tenancy
+      self.opsworks = opsworks
+      self.cli = cli
+    end
+
+    def clone(options)
+      all_sibling_hostnames = self.layer.instances.collect { |instance| instance.hostname }
+      new_instance_hostname = make_new_hostname(self.hostname, all_sibling_hostnames)
+      puts "\nWe will make a new instance with hostname: #{new_instance_hostname}"
+
+      options[:ami] ? ami_id = options[:ami] : ami_id = self.ami_id
+      options[:instance_type] ? instance_type = options[:instance_type] : instance_type = self.instance_type
+      options[:agent_version] ? agent_version = options[:agent_version] : agent_version = self.agent_version
+
+      create_new_instance(new_instance_hostname, instance_type, ami_id, agent_version)
+    end
+
+    def make_new_hostname(old_hostname, all_hostnames)
+      if old_hostname =~ /\d\d\z/
+        new_instance_hostname = increment_hostname(old_hostname, all_hostnames)
+      else
+        new_instance_hostname = old_hostname << "_clone"
+      end
+        
+      puts "\nAutomatically generated hostname: #{new_instance_hostname}\n"
+      rewriting = @cli.ask("Do you wish to rewrite this hostname?\n1) Yes\n2) No", Integer)
+
+      if rewriting == 1
+        new_instance_hostname = @cli.ask("Please write in the new instance's hostname and press ENTER:")
+      end
+
+      new_instance_hostname
+    end
+
+    def increment_hostname(hostname, all_hostnames)
+      until hostname_unique?(hostname, all_hostnames) do
+        hostname = hostname.gsub(/(\d\d\z)/) { "#{($1.to_i + 1).to_s.rjust(2, '0')}" }
+      end
+      hostname
+    end
+
+    def hostname_unique?(hostname, all_hostnames)
+      !all_hostnames.include?(hostname)
+    end
+
+    def create_new_instance(new_instance_hostname, instance_type, ami_id, agent_version)
+      new_instance = @opsworks.create_instance({
+        stack_id: self.stack_id, # required
+        layer_ids: self.layer_ids, # required
+        instance_type: instance_type, # required
+        auto_scaling_type: self.auto_scaling_type, # accepts load, timer
+        hostname: new_instance_hostname,
+        os: self.os,
+        ami_id: ami_id,
+        ssh_key_name: self.ssh_key_name,
+        availability_zone: self.availability_zone,
+        virtualization_type: self.virtualization_type,
+        subnet_id: self.subnet_id,
+        architecture: self.architecture, # accepts x86_64, i386
+        root_device_type: self.root_device_type, # accepts ebs, instance-store
+        install_updates_on_boot: self.install_updates_on_boot,
+        #ebs_optimized: self.ebs_optimized,
+        agent_version: agent_version,
+        tenancy: self.tenancy,
+      })
+      puts "New instance is created: #{new_instance.instance_id}"
+    end
+  end
+end

data/lib/opsicle/cloneable_layer.rb

@@ -0,0 +1,21 @@
+module Opsicle
+  class CloneableLayer
+    attr_accessor :name, :layer_id, :instances, :opsworks, :cli
+
+    def initialize(name, layer_id, opsworks, cli)
+      self.name = name
+      self.layer_id = layer_id
+      self.opsworks = opsworks
+      self.cli = cli
+      self.instances = []
+    end
+
+    def get_cloneable_instances
+      ops_instances = @opsworks.describe_instances({ :layer_id => layer_id }).instances
+      ops_instances.each do |instance|
+        self.instances << CloneableInstance.new(instance, self, @opsworks, @cli)
+      end
+      self.instances
+    end
+  end
+end

data/lib/opsicle/cloneable_stack.rb

@@ -0,0 +1,15 @@
+module Opsicle
+  class CloneableStack
+    attr_accessor :id, :opsworks, :stack
+
+    def initialize(stack_id, opsworks)
+      self.id = stack_id
+      self.opsworks = opsworks
+      self.stack = get_stack
+    end
+
+    def get_stack
+      @opsworks.describe_stacks({ :stack_ids => [self.id.to_s] }).stacks.first
+    end
+  end
+end

data/lib/opsicle/commands.rb

@@ -2,6 +2,7 @@ require 'opsicle/client'
 
 require "opsicle/commands/deploy"
 require "opsicle/commands/chef_update"
+require "opsicle/commands/clone_instance"
 require "opsicle/commands/execute_recipes"
 require "opsicle/commands/list"
 require "opsicle/commands/list_instances"

data/lib/opsicle/commands/clone_instance.rb

@@ -0,0 +1,57 @@
+require 'gli'
+require "opsicle/user_profile"
+require "opsicle/cloneable_layer"
+require "opsicle/cloneable_instance"
+require "opsicle/cloneable_stack"
+
+module Opsicle
+  class CloneInstance
+
+    def initialize(environment)
+      @client = Client.new(environment)
+      @opsworks = @client.opsworks
+      stack_id = @client.config.opsworks_config[:stack_id]
+      @stack = CloneableStack.new(@client.config.opsworks_config[:stack_id], @opsworks)
+      @cli = HighLine.new
+    end
+
+    def execute(options={})
+      puts "Stack ID = #{@stack.id}"
+      layer = select_layer
+      all_instances = layer.get_cloneable_instances
+      instances_to_clone = select_instances(all_instances)
+
+      instances_to_clone.each do |instance|
+        instance.clone(options)
+      end
+    end
+
+    def select_layer
+      puts "\nLayers:\n"
+      ops_layers = @opsworks.describe_layers({ :stack_id => @stack.id }).layers
+
+      layers = []
+      ops_layers.each do |layer|
+        layers << CloneableLayer.new(layer.name, layer.layer_id, @opsworks, @cli)
+      end
+
+      layers.each_with_index { |layer, index| puts "#{index.to_i + 1}) #{layer.name}"}
+      layer_index = @cli.ask("Layer?\n", Integer) { |q| q.in = 1..layers.length.to_i } - 1
+      layers[layer_index]
+    end
+
+    def select_instances(instances)
+      puts "\nInstances:\n"
+      instances.each_with_index { |instance, index| puts "#{index.to_i + 1}) #{instance.status} - #{instance.hostname}" }
+      instance_indices_string = @cli.ask("Instances? (enter as a comma separated list)\n", String)
+      instance_indices_list = instance_indices_string.split(/,\s*/)
+      instance_indices_list.map! { |instance_index| instance_index.to_i - 1 }
+      
+      return_array = []
+      instance_indices_list.each do |index|
+        return_array << instances[index]
+      end
+      return_array
+    end
+  end
+end

data/lib/opsicle/version.rb

@@ -1,3 +1,3 @@
 module Opsicle
-  VERSION = "2.0.2"
+  VERSION = "2.1.0"
 end

data/spec/opsicle/cloneable_instance_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+require "opsicle"
+require 'gli'
+require "opsicle/user_profile"
+
+module Opsicle
+  describe CloneableInstance do
+    before do
+      @instance = double('instance1', :hostname => 'example-hostname-01', :status => 'active',
+                                       :ami_id => 'ami_id', :instance_type => 'instance_type',
+                                       :agent_version => 'agent_version', :stack_id => 1234567890,
+                                       :layer_ids => [12345, 67890], :auto_scaling_type => 'auto_scaling_type',
+                                       :os => 'os', :ssh_key_name => 'ssh_key_name',
+                                       :availability_zone => 'availability_zone', :virtualization_type => 'virtualization_type',
+                                       :subnet_id => 'subnet_id', :architecture => 'architecture',
+                                       :root_device_type => 'root_device_type', :install_updates_on_boot => 'install_updates_on_boot',
+                                       :ebs_optimized => 'ebs_optimized', :tenancy => 'tenancy')
+      @layer = double('layer1', :name => 'layer-1', :layer_id => 12345, :instances => [@instance])
+      @new_instance = double('new_instance', :instance_id => 1029384756)
+      @opsworks = double('opsworks', :create_instance => @new_instance)
+      @cli = double('cli', :ask => 2)
+    end
+
+    context "#make_new_hostname" do
+      it "should make a unique incremented hostname" do
+        instance = CloneableInstance.new(@instance, @layer, @opsworks, @cli)
+        expect(instance).to receive(:increment_hostname).and_return('example-hostname-03')
+        instance.make_new_hostname('example-hostname-01', ['example-hostname-01', 'example-hostname-02'])
+      end
+    end
+
+    context "#increment_hostname" do
+      it "should increment the hostname" do
+        instance = CloneableInstance.new(@instance, @layer, @opsworks, @cli)
+        expect(instance).to receive(:hostname_unique?).and_return('example-hostname-03')
+        instance.increment_hostname('example-hostname-01', ['example-hostname-01', 'example-hostname-02'])
+      end
+    end
+
+    context "#clone" do
+      it "should grab instances and make new hostname" do
+        instance = CloneableInstance.new(@instance, @layer, @opsworks, @cli)
+        expect(@layer).to receive(:instances)
+        expect(instance).to receive(:make_new_hostname).and_return('example-hostname-03')
+        instance.clone({})
+      end
+
+      it "should get information from old instance" do
+        instance = CloneableInstance.new(@instance, @layer, @opsworks, @cli)
+        expect(instance).to receive(:agent_version)
+        expect(instance).to receive(:ami_id)
+        expect(instance).to receive(:instance_type)
+        instance.clone({})
+      end
+
+      it "should create new instance" do
+        instance = CloneableInstance.new(@instance, @layer, @opsworks, @cli)
+        expect(instance).to receive(:create_new_instance)
+        instance.clone({})
+      end
+    end
+
+    context "#create_new_instance" do
+      it "should create an instance" do
+        instance = CloneableInstance.new(@instance, @layer, @opsworks, @cli)
+        expect(@opsworks).to receive(:create_instance)
+        instance.create_new_instance('hostname', 'type', 'ami', 'agent_version')
+      end
+
+      it "should take information from old instance" do
+        instance = CloneableInstance.new(@instance, @layer, @opsworks, @cli)
+        expect(instance).to receive(:stack_id)
+        expect(instance).to receive(:layer_ids)
+        expect(instance).to receive(:auto_scaling_type)
+        expect(instance).to receive(:os)
+        expect(instance).to receive(:ssh_key_name)
+        expect(instance).to receive(:availability_zone)
+        expect(instance).to receive(:virtualization_type)
+        expect(instance).to receive(:subnet_id)
+        instance.create_new_instance('hostname', 'type', 'ami', 'agent_version')
+      end
+    end
+  end
+end

data/spec/opsicle/cloneable_layer_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+require "opsicle"
+require 'gli'
+require "opsicle/user_profile"
+
+module Opsicle
+  describe CloneableLayer do
+    before do
+      @instance1 = double('instance1', :hostname => 'example-hostname-01', :status => 'active',
+                                       :ami_id => 'ami_id', :instance_type => 'instance_type',
+                                       :agent_version => 'agent_version', :stack_id => 1234567890,
+                                       :layer_ids => [12345, 67890], :auto_scaling_type => 'auto_scaling_type',
+                                       :os => 'os', :ssh_key_name => 'ssh_key_name',
+                                       :availability_zone => 'availability_zone', :virtualization_type => 'virtualization_type',
+                                       :subnet_id => 'subnet_id', :architecture => 'architecture',
+                                       :root_device_type => 'root_device_type', :install_updates_on_boot => 'install_updates_on_boot',
+                                       :ebs_optimized => 'ebs_optimized', :tenancy => 'tenancy')
+      @instance2 = double('instance2', :hostname => 'example-hostname-02', :status => 'active',
+                                       :ami_id => 'ami_id', :instance_type => 'instance_type',
+                                       :agent_version => 'agent_version', :stack_id => 1234567890,
+                                       :layer_ids => [12345, 67890], :auto_scaling_type => 'auto_scaling_type',
+                                       :os => 'os', :ssh_key_name => 'ssh_key_name',
+                                       :availability_zone => 'availability_zone', :virtualization_type => 'virtualization_type',
+                                       :subnet_id => 'subnet_id', :architecture => 'architecture',
+                                       :root_device_type => 'root_device_type', :install_updates_on_boot => 'install_updates_on_boot',
+                                       :ebs_optimized => 'ebs_optimized', :tenancy => 'tenancy')
+      @instances = double('instances', :instances => [@instance1, @instance2])
+      @opsworks = double('opsworks', :describe_instances => @instances)
+    end
+
+    context "#get_cloneable_instances" do
+      it "should gather opsworks instances for that layer" do
+        layer = CloneableLayer.new('layer-name', 12345, @opsworks, @cli)
+        expect(@opsworks).to receive(:describe_instances).and_return(@instances)
+        expect(@instances).to receive(:instances)
+        layer.get_cloneable_instances
+      end
+
+      it "should make a new CloneableInstance for each instance" do
+        layer = CloneableLayer.new('layer-name', 12345, @opsworks, @cli)
+        expect(CloneableInstance).to receive(:new).twice
+        layer.get_cloneable_instances
+      end
+    end
+  end
+end

data/spec/opsicle/cloneable_stack_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "opsicle"
+require 'gli'
+require "opsicle/user_profile"
+
+module Opsicle
+  describe CloneableStack do
+    before do
+      @stack = double('stack')
+      @stacks = double('stacks', :stacks => [@stack])
+      @opsworks = double('opsworks', :describe_stacks => @stacks)
+    end
+
+    context "#get_stack" do
+      it "should gather opsworks instances for that layer" do
+        stack = CloneableStack.new(12345, @opsworks)
+        expect(@opsworks).to receive(:describe_stacks).and_return(@stacks)
+        expect(@stacks).to receive(:stacks)
+        stack.get_stack
+      end
+    end
+  end
+end

data/spec/opsicle/commands/clone_instance_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+require "opsicle"
+require 'gli'
+require "opsicle/user_profile"
+
+module Opsicle
+  describe CloneInstance do
+    before do
+      @instance1 = double('instance1', :hostname => 'example-hostname-01', :status => 'active',
+                                       :ami_id => 'ami_id', :instance_type => 'instance_type',
+                                       :agent_version => 'agent_version', :stack_id => 1234567890,
+                                       :layer_ids => [12345, 67890], :auto_scaling_type => 'auto_scaling_type',
+                                       :os => 'os', :ssh_key_name => 'ssh_key_name',
+                                       :availability_zone => 'availability_zone', :virtualization_type => 'virtualization_type',
+                                       :subnet_id => 'subnet_id', :architecture => 'architecture',
+                                       :root_device_type => 'root_device_type', :install_updates_on_boot => 'install_updates_on_boot',
+                                       :ebs_optimized => 'ebs_optimized', :tenancy => 'tenancy')
+      @instance2 = double('instance2', :hostname => 'example-hostname-02', :status => 'active',
+                                       :ami_id => 'ami_id', :instance_type => 'instance_type',
+                                       :agent_version => 'agent_version', :stack_id => 1234567890,
+                                       :layer_ids => [12345, 67890], :auto_scaling_type => 'auto_scaling_type',
+                                       :os => 'os', :ssh_key_name => 'ssh_key_name',
+                                       :availability_zone => 'availability_zone', :virtualization_type => 'virtualization_type',
+                                       :subnet_id => 'subnet_id', :architecture => 'architecture',
+                                       :root_device_type => 'root_device_type', :install_updates_on_boot => 'install_updates_on_boot',
+                                       :ebs_optimized => 'ebs_optimized', :tenancy => 'tenancy')
+      @instances = double('instances', :instances => [@instance1, @instance2])
+      @layer1 = double('layer1', :name => 'layer-1', :layer_id => 12345, :instances => [@instance1, @instance2])
+      @layer2 = double('layer2', :name => 'layer-2', :layer_id => 67890, :instances => [@instance1, @instance2])
+      @layers = double('layers', :layers => [@layer1, @layer2])
+      @new_instance = double('new_instance', :instance_id => 1029384756)
+      @stack = double('stack')
+      @stacks = double('stacks', :stacks => [@stack])
+      @opsworks = double('opsworks', :describe_instances => @instances, :describe_layers => @layers,
+                                     :create_instance => @new_instance, :describe_stacks => @stacks)
+      @config = double('config', :opsworks_config => {:stack_id => 1234567890})
+      @client = double('client', :config => @config, :opsworks => @opsworks)
+      allow(Client).to receive(:new).with(:environment).and_return(@client)
+      allow(@instances).to receive(:each_with_index)
+      allow_any_instance_of(HighLine).to receive(:ask).with("Layer?\n", Integer).and_return(2)
+      allow_any_instance_of(HighLine).to receive(:ask).with("Instances? (enter as a comma separated list)\n", String).and_return('2')
+      allow_any_instance_of(HighLine).to receive(:ask).with("Do you wish to rewrite this hostname?\n1) Yes\n2) No", Integer).and_return(2)
+      allow_any_instance_of(HighLine).to receive(:ask).with("Please write in the new instance's hostname and press ENTER:").and_return('example-hostname')
+    end
+    
+    context "#execute" do
+      it "lists all current layers" do
+        expect(@opsworks).to receive(:describe_layers)
+        CloneInstance.new(:environment).execute
+      end
+
+      it "lists all current instances" do
+        expect(@opsworks).to receive(:describe_instances)
+        CloneInstance.new(:environment).execute
+      end
+    end
+
+    context "#select_layer" do
+      it "should list layers" do
+        expect(@opsworks).to receive(:describe_layers)
+        CloneInstance.new(:environment).select_layer
+      end
+
+      it "should get the layer id" do
+        expect(@layer2).to receive(:layer_id)
+        CloneInstance.new(:environment).select_layer
+      end
+    end
+
+    context "#select_instances" do
+      it "should list instances" do
+        expect(@instances).to receive(:[])
+        CloneInstance.new(:environment).select_instances(@instances)
+      end
+    end
+
+    context "#client" do
+      it "generates a new AWS client from the given configs" do
+        @config = double('config', :opsworks_config => {:stack_id => 1234567890})
+        @client = double('client', :config => @config,
+                                   :opsworks => @opsworks)
+        expect(Client).to receive(:new).with(:environment).and_return(@client)
+        CloneInstance.new(:environment)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opsicle
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Andy Fleener
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-08 00:00:00.000000000 Z
+date: 2016-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -191,8 +191,12 @@ files:
 - bin/opsicle
 - lib/opsicle.rb
 - lib/opsicle/client.rb
+- lib/opsicle/cloneable_instance.rb
+- lib/opsicle/cloneable_layer.rb
+- lib/opsicle/cloneable_stack.rb
 - lib/opsicle/commands.rb
 - lib/opsicle/commands/chef_update.rb
+- lib/opsicle/commands/clone_instance.rb
 - lib/opsicle/commands/deploy.rb
 - lib/opsicle/commands/execute_recipes.rb
 - lib/opsicle/commands/failure_log.rb
@@ -231,7 +235,11 @@ files:
 - lib/opsicle/user_profile.rb
 - lib/opsicle/version.rb
 - spec/opsicle/client_spec.rb
+- spec/opsicle/cloneable_instance_spec.rb
+- spec/opsicle/cloneable_layer_spec.rb
+- spec/opsicle/cloneable_stack_spec.rb
 - spec/opsicle/commands/chef_update_spec.rb
+- spec/opsicle/commands/clone_instance_spec.rb
 - spec/opsicle/commands/deploy_spec.rb
 - spec/opsicle/commands/execute_recipes_spec.rb
 - spec/opsicle/commands/failure_log_spec.rb
@@ -280,7 +288,11 @@ specification_version: 4
 summary: An opsworks specific abstraction on top of the aws sdk
 test_files:
 - spec/opsicle/client_spec.rb
+- spec/opsicle/cloneable_instance_spec.rb
+- spec/opsicle/cloneable_layer_spec.rb
+- spec/opsicle/cloneable_stack_spec.rb
 - spec/opsicle/commands/chef_update_spec.rb
+- spec/opsicle/commands/clone_instance_spec.rb
 - spec/opsicle/commands/deploy_spec.rb
 - spec/opsicle/commands/execute_recipes_spec.rb
 - spec/opsicle/commands/failure_log_spec.rb