unimatrix-cli 2.2.0

data/lib/unimatrix_cli/citadel/app/routes_command.rb

@@ -0,0 +1,17 @@
+module UnimatrixCLI
+  module Citadel
+    module App
+      class RoutesCommand < CitadelCommand
+
+        option :app, "Keyword for the name of the app", type: :string, required: true
+
+        synopsis "Display rails routes on a Rails-based API instance"
+
+        def execute
+          super
+          execute_command( 'routes' )
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/citadel/citadel_command.rb

@@ -0,0 +1,285 @@
+require 'tty-prompt'
+require 'aws-sdk'
+require 'net/ssh'
+
+module UnimatrixCLI
+  module Citadel
+    class CitadelCommand < Command
+
+      APIS = %w( activist alchemist analyst anemoi archivist  
+        cartographer curator distributor dealer fabricator iris    
+        keymaker merchant organizer portal regent universal zephyrus )
+      
+      ROOT = %w( status bastion efsm environment user_data_logs )
+      
+      PRIVATE_SUBNETS = %w( subnet-6788a72c subnet-761b7a59 subnet-71340a38
+        subnet-db541df6 subnet-699ce444 subnet-dbeeddf6 
+        subnet-cf507986 subnet-7cedde51 subnet-5e505816 )
+      
+      def execute
+        if load_environment && instance_list
+          write_instance_details( instance_details[ :instance_id ] )
+        end
+      end
+
+      def load_environment
+        Dotenv.load if defined?( Dotenv )
+        if ENV[ 'AWS_REGION' ] &&
+           ENV[ 'server_key' ] &&
+           ENV[ 'AWS_ACCESS_KEY_ID' ] &&
+           ENV[ 'AWS_SECRET_ACCESS_KEY' ]
+
+          Aws.config.update({
+            region: ENV[ 'AWS_REGION' ],
+            credentials: Aws::Credentials.new( 
+              ENV[ 'AWS_ACCESS_KEY_ID' ],
+              ENV[ 'AWS_SECRET_ACCESS_KEY' ]
+            )
+          })
+        else
+          write( message: 'AWS credentials not found', error: true )
+          false
+        end
+      end
+
+      #----------------------------------------------------------------------------
+      # Memoized Variables
+
+      def instance_list
+        @instance_list ||= begin
+          app_keyword = @options[ :builder ] || @options[ :app ] || @options[ :instance ]
+          instance_list = instances( app_keyword )
+
+          if instance_list
+            instance_list
+          else
+            write( message: 'Instances not found', error: true )
+            false
+          end
+        end
+      end
+
+      def aws_client
+        @aws_client ||= Aws::EC2::Client.new
+      end
+
+      def instance_details
+        @instance_details ||= begin
+          names = instance_list.map { | instance | instance.keys }.flatten
+          chosen_instance = names.length == 1 ? names.first : menu( names )
+          collect_instance_details( chosen_instance )
+        end
+      end
+
+      def instances_by_zone
+        @instances_by_zone ||= begin
+          app_keyword = @options[ :builder ] || @options[ :app ] || @options[ :instance ]
+          find_instances_by_zone( app_keyword )
+        end
+      end
+
+      def user
+        @user ||= begin
+          sub_command = self.class.to_s.split( '::' ).last.slice( 0...-7 ).downcase
+          if ROOT.include?( @options[ :user ] ) || 
+             ROOT.include?( sub_command ) ||
+             ROOT.include?( instance_details[ :tag ].split( '-' ).first ) ||
+             ROOT.include?( instance_details[ :tag ].split( '.' ).first ) ||
+             instance_details[ :tag ].include?( 'bastion' ) ||
+             instance_details[ :tag ].include?( 'efsm' )
+            'root'
+          elsif instance_details[ :tag ].include?( 'worker' )
+            'worker'
+          elsif instance_details[ :tag ].include?( 'build' )
+            'ec2-user'
+          elsif APIS.include?( 
+            instance_details[ :tag ].split( '-' ).first 
+          )
+            'httpd'
+          else
+            instance_details[ :tag ].split( '-' ).first
+          end
+        end
+      end
+
+      def key
+        @key ||= File.join( '~/.ssh/', ENV[ 'server_key' ] )
+      end
+
+      def account
+        @account ||= begin
+          id = aws_client.describe_instances.reservations.first[ :owner_id ]
+          id == '561599644983' ? account = 'production' : account = 'development'
+        end
+      end
+
+      #----------------------------------------------------------------------------
+      # Instance Details
+
+      def write_instance_details( instance_id, options = {} )
+        instance = aws_client.describe_instances(
+          filters:[ { name: 'instance-id', values: [ instance_id ] } ] 
+        ).first.to_h[ :reservations ].first[ :instances ].first
+
+        message = "Name: #{ instance[ :tags ].first[ :value ] }\n" +
+          "Instance ID: #{ instance[ :instance_id ] }\n" +
+          "Public DNS: #{ instance[ :public_dns_name ] }\n"
+
+        if options[ :full ]
+          message += "Launch Time: #{ instance[ :launch_time ] }\n" +
+            "Instance Type: #{ instance[ :instance_type ] }\n"
+
+          if instance[ :iam_instance_profile ]
+            message += "Instance Profile: " +
+              "#{ instance[ :iam_instance_profile ][ :arn ] }"
+          end
+        end
+
+        write( message: message )
+      end
+
+      private; def instances( app_keyword )
+        available_instances = find_instances_by_zone( app_keyword ).flatten.map do | instance |
+          if instance[ :state ][ :name ] == 'running'
+            { instance[ :tags ].find { | item | item[ :key ] == 'Name' }[ :value ] + 
+              ' ' + '(' + instance[ :instance_id ] +
+            ')' => instance[ :public_dns_name ] 
+            }
+          end
+        end
+        if available_instances.empty? || 
+           ( available_instances.include?( nil ) && available_instances.count == 1 )
+          false
+        else
+          available_instances.compact
+        end
+      end
+
+      private; def find_instances_by_zone( app_keyword )
+        descriptions = aws_client.describe_instances( 
+          filters:[ { name: 'tag:Name', values: [ "*#{ app_keyword }*" ] } ] 
+        ).to_h
+
+        instances_hash = descriptions.map { | hash | hash[ 1 ] }.first
+        instances_by_zone = instances_hash.map do | instances | 
+          instances[ :instances ] 
+        end.flatten
+      end
+
+      private; def menu( names )
+        prompt = TTY::Prompt.new( 
+          interrupt: :exit, help_color: :magenta, prefix: 'Citadel:' 
+        )
+        prompt.select( 'Select?', names, active_color: :cyan  )
+      end
+
+      private; def development_vpc( vpc )
+        vpc == 'vpc-009eb264' ? environment = 'acceptance' : environment = 'staging'
+      end
+
+      private; def collect_instance_details( chosen_instance )
+        dns = instance_list.reduce( 
+          Hash.new, :merge 
+        ).select { | key, value | key == chosen_instance }[ chosen_instance ]
+        
+        instance_id = chosen_instance.split( ' ' )[ -1 ].gsub( /[()]/, "" )
+        tag = chosen_instance.split( ' ' ).first
+
+        subnet_hash = instances_by_zone.map do | instance |
+          if instance[ :state ][ :name ] == 'running'
+            { instance[ :instance_id ] => instance[ :subnet_id ] }
+          end
+        end
+
+        subnets = subnet_hash.compact.reduce( Hash.new, :merge )
+        chosen_subnet = subnets[ instance_id ]
+        
+        concealed = PRIVATE_SUBNETS.any? do | private_subnet | 
+          chosen_subnet.include?( private_subnet )
+        end
+        
+        vpc_hash = instances_by_zone.map do | instance |
+          if instance[ :state ][ :name ] == 'running'
+            { instance[ :instance_id ] => instance[ :vpc_id ] }
+          end
+        end
+
+        vpcs = vpc_hash.compact.reduce( Hash.new, :merge )
+
+        if account == 'development'
+          development_environment = development_vpc( vpcs[ instance_id ] )
+          bastion_hash = instances(
+            "bastion.#{ development_environment }.#{ ENV[ 'AWS_REGION' ] }"
+          )
+        else
+          bastion_hash = instances( "bastion.#{ ENV[ 'AWS_REGION' ] }" )
+        end
+
+        bastion_dns = bastion_hash.reduce( Hash.new, :merge ).values.first
+
+        {
+          bastion_dns: bastion_dns,
+          dns: dns,
+          tag: tag,
+          instance_id: instance_id,
+          account: account,
+          concealed: concealed
+        }
+      end
+
+      #----------------------------------------------------------------------------
+      # Command Execution
+
+      def execute_command( remote_command )
+        command = base_command + 
+          "  -t commands #{ remote_command }"
+        command += " #{ @options[ :commands ] }" if @options[ :commands ]
+        exec command
+      end
+
+      private; def base_command
+        base = "ssh -o StrictHostKeyChecking=no -i #{ key } "
+
+        if instance_details[ :bastion_dns ] == instance_details[ :dns ] || 
+           instance_details[ :tag ] == 'efsm'
+
+          base += "root@#{ instance_details[ :dns ] }"
+
+        elsif instance_details[ :account ] == 'production' ||
+              instance_details[ :concealed ]
+
+          base += "root@#{ instance_details[ :bastion_dns ] }"
+
+        else
+          user_to_use = @options[ :user ] || user
+          base += "#{ user_to_use }@#{ instance_details[ :dns ] }"
+        end
+      end
+
+      def execute_tunnel( remote_command )
+        write( 
+          message: 'Running Via SSH Tunnel. ' +
+            'This command could take a while; please be patient.'
+        )
+        if instance_details[ :account ] == 'production' ||
+           instance_details[ :concealed ]
+
+          user_to_use = 'root'
+          dns_to_use = instance_details[ :bastion_dns ]
+          to_exec = "/home/root/scripts/intraface " +
+            "#{ instance_details[ :instance_id ] } root" +
+            "-t -t #{ remote_command }"
+        else
+          user_to_use = user
+          dns_to_use = instance_details[ :dns ]
+          to_exec = "#{ remote_command }"
+        end
+
+        Net::SSH.start( dns_to_use, user_to_use, keys: [ key ] ) do | ssh |
+          output = ssh.exec!( to_exec )
+          write( message: output )
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/citadel/instance/details_command.rb

@@ -0,0 +1,18 @@
+module UnimatrixCLI
+  module Citadel
+    module Instance
+      class DetailsCommand < CitadelCommand
+
+        option :instance, "Keyword for the name of the instance", type: :string, required: :true
+
+        synopsis "Display full details for the specified instance"
+
+        def execute
+          if load_environment && instance_list
+            write_instance_details( instance_details[ :instance_id ], full: true )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/citadel/instance/scp_command.rb

@@ -0,0 +1,48 @@
+module UnimatrixCLI
+  module Citadel
+    module Instance
+      class ScpCommand < CitadelCommand
+
+        option :instance,    "The instance to copy a file from or to", type: :string, required: true
+        option :local_file,  "The local path and filename",            type: :string, required: true     
+        option :remote_file, "The remote path and filename",           type: :string, required: true
+        option :direction,   "Copy from or to an instance",            type: :string, required: true
+        option :user,        "Connect as a different user (optional)", type: :string
+
+        synopsis "Copy a file from or to a specific instance"
+
+        DIRECTIONS = %w( from to )
+
+        def execute
+          if @options[ :direction ] && 
+             DIRECTIONS.include?( @options[ :direction ] )
+            super
+            execute_scp
+          else
+            write( 
+              message: "#{ @options[ :direction ] } is not a valid direction", 
+              error: true
+            )
+          end
+        end
+
+        #----------------------------------------------------------------------------
+
+        def execute_scp
+          user_to_use = @options[ :user ] || user
+          base = "scp -o StrictHostKeyChecking=no -i #{ key } "
+
+          if @options[ :direction ] == 'to'
+            command = base + "#{ @options[ :local_file ] } #{ user_to_use }@" +
+              "#{ instance_details[ :dns ] }:#{ @options[ :remote_file ] }"
+          else
+            command = base + "#{ user_to_use }@#{ instance_details[ :dns ] }" +
+              ":#{ @options[ :remote_file ] } #{ @options[ :local_file ] }"
+          end
+
+          exec command
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/citadel/instance/ssh_command.rb

@@ -0,0 +1,29 @@
+module UnimatrixCLI
+  module Citadel
+    module Instance
+      class SshCommand < CitadelCommand
+
+        option :instance, "Keyword for the name of the instance",   type: :string, required: true
+        option :user,     "Connect as a different user (optional)", type: :string
+        option :commands, "Remote commands (optional)",             type: :string
+
+        synopsis "Enter ssh shell on the specified instance"
+
+        def execute
+          super
+          execute_shell
+        end
+
+        #----------------------------------------------------------------------------
+
+        def execute_shell
+          command = base_command
+          if @options[ :commands ]
+            command += " #{ @options[ :commands ] }"
+          end
+          exec command
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/citadel/instance/status_command.rb

@@ -0,0 +1,17 @@
+module UnimatrixCLI
+  module Citadel
+    module Instance
+      class StatusCommand < CitadelCommand
+
+        option :instance, "Keyword for the name of the instance", type: :string, required: :true
+
+        synopsis "Display bluepill status for the specified instance"
+
+        def execute
+          super
+          execute_tunnel( 'bluepilld status' )
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/citadel/instance/user_data_command.rb

@@ -0,0 +1,17 @@
+module UnimatrixCLI
+  module Citadel
+    module Instance
+      class UserDataCommand < CitadelCommand
+
+        option :instance, "Keyword for the name of the instance", type: :string, required: :true
+
+        synopsis "Display user_data for the specified instance"
+
+        def execute
+          super
+          execute_tunnel( 'cat /tmp/user-data' )
+        end
+      end
+    end
+  end
+end

data/lib/unimatrix_cli/citadel/instance/user_data_logs_command.rb

@@ -0,0 +1,17 @@
+module UnimatrixCLI
+  module Citadel
+    module Instance
+      class UserDataLogsCommand < CitadelCommand
+
+        option :instance, "Keyword for the name of the instance", type: :string, required: :true
+
+        synopsis "Display user_data logs for the specified instance"
+
+        def execute
+          super
+          execute_tunnel( 'cat /var/log/user-data.log' )
+        end
+      end
+    end
+  end
+end