nex_client 0.1.0

data/lib/nex_client/commands/cube_templates.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+module NexClient
+  module Commands
+    module CubeTemplates
+      extend Helpers
+
+      TEMPLATES_TITLE = "Cube Templates".colorize(:red)
+      TEMPLATES_HEADERS = ['id','name','image','tag','layer','min_pu','stack'].map(&:upcase)
+
+      def self.list(args,opts)
+        filters = {}
+        filters[:human_id] = opts.name if opts.name.present?
+        filters[:stack] = opts.stack if opts.stack.present?
+        filters[:image] = opts.image if opts.image.present?
+
+        # Create table
+        list = NexClient::CubeTemplate.where(filters).order('human_id')
+        self.display_templates(list)
+      end
+
+      def self.display_templates(list)
+        table = Terminal::Table.new title: TEMPLATES_TITLE, headings: TEMPLATES_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            t.add_row(self.format_record(e))
+          end
+        end
+        puts table
+        puts "\n"
+      end
+
+      def self.format_record(record)
+        [
+          record.id,
+          record.human_id,
+          record.image,
+          record.tag,
+          record.layer,
+          record.min_pu,
+          record.stack
+        ]
+      end
+    end
+  end
+end

data/lib/nex_client/commands/domains.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+module NexClient
+  module Commands
+    module Domains
+      extend Helpers
+
+      DOMAINS_TITLE = "Domains".colorize(:magenta)
+      DOMAINS_HEADERS = ['id','cname','origin'].map(&:upcase)
+
+      def self.list(args,opts)
+        filters = {}
+        filters[:'origin.name'] = args.first if args.first.present?
+
+        # Create table
+        list = NexClient::Domain.includes(:origin).where(filters).order('cname')
+        self.display_domains(list)
+      end
+
+      def self.create(args,opts)
+        domain_name,app_name = args
+        app = NexClient::App.find(name: app_name).first
+        app ||= NexClient::CubeInstance.find(name: app_name).first
+
+        # Display error
+        unless app
+          error("Error! Could not find app: #{app_name}")
+          return false
+        end
+
+        domain = NexClient::Domain.new(cname: domain_name)
+        domain.relationships.attributes = { origin: { data: { type: app.type, id: app.id } } }
+        domain.save
+
+        # Display errors if any
+        if domain.errors.any?
+          display_record_errors(domain)
+          return false
+        end
+
+        # Display domains
+        self.display_domains(NexClient::Domain.includes(:origin).find(domain.id).first)
+      end
+
+      def self.destroy(args,opts)
+        name = args.first
+        e = NexClient::Domain.find(cname: name).first
+
+        # Display error
+        unless e
+          error("Error! Could not find domain: #{name}")
+          return false
+        end
+
+        # Ask confirmation
+        answer = ask("Enter the name of this domain to confirm: ")
+        unless answer == e.cname
+          error("Aborting deletion...")
+          return false
+        end
+
+        e.destroy
+        success("Successfully destroyed domain: #{name}")
+      end
+
+      def self.display_domains(list)
+        table = Terminal::Table.new title: DOMAINS_TITLE, headings: DOMAINS_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            t.add_row(self.format_record(e))
+          end
+        end
+        puts table
+        puts "\n"
+      end
+
+      def self.format_record(record)
+        origin = self.format_origin(record)
+        [
+          record.id,
+          record.cname,
+          origin
+        ]
+      end
+
+      def self.format_origin(record)
+        return "-" unless record.origin
+        record.origin.name
+      end
+    end
+  end
+end

data/lib/nex_client/commands/helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module NexClient
+  module Commands
+    module Helpers
+
+      def display_record_errors(record)
+        record.errors.messages.each do |k,v|
+          v.each { |m| puts "#{k} #{m}" }
+        end
+      end
+
+      def success(msg)
+        puts msg.colorize(:green)
+      end
+
+      def error(msg)
+        puts msg.colorize(:red)
+      end
+    end
+  end
+end

data/lib/nex_client/commands/organizations.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module NexClient
+  module Commands
+    module Organizations
+      extend Helpers
+
+      ORGS_TITLE = "Organizations".colorize(:green)
+      ORGS_HEADERS = ['id','name','handle'].map(&:upcase)
+
+      def self.list(args,opts)
+        # Create table
+        self.display_organizations(NexClient::Organization.order('handle'))
+      end
+
+      def self.display_organizations(list)
+        table = Terminal::Table.new title: ORGS_TITLE, headings: ORGS_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            t.add_row([e.id,e.name,e.handle])
+          end
+        end
+        puts table
+        puts "\n"
+      end
+
+    end
+  end
+end

data/lib/nex_client/commands/racks.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+module NexClient
+  module Commands
+    module Racks
+      extend Helpers
+
+      COMPUTE_RACKS_TITLE = "Compute Racks".colorize(:cyan)
+      STORAGE_RACKS_TITLE = "Storage Racks".colorize(:blue)
+      ROUTING_RACKS_TITLE = "Routing Racks".colorize(:green)
+      GATEWAY_RACKS_TITLE = "Gateway Racks".colorize(:yellow)
+      RACKS_HEADERS = ['type','id','region','stack','status','iip','eip','capacity'].map(&:upcase)
+
+      def self.list(args,opts)
+        filters = {}
+
+        # Type filter
+        only_type = opts.type
+        only_type = 'compute' if opts.stack.present?
+
+        # Status filter
+        filters[:status] = opts.status || 'running'
+
+        # Stack filter
+        if opts.stack.present?
+          filters[:stack] = opts.stack
+        end
+
+        # All option
+        filters = {} if opts.all
+
+        # Create table
+        if !only_type || only_type == 'compute'
+          self.display_compute_racks(NexClient::ComputeRack.where(filters).order('aws_region,status'))
+        end
+
+        if !only_type || only_type == 'storage'
+          self.display_storage_racks(NexClient::StorageRack.where(filters).order('aws_region,status'))
+        end
+
+        if !only_type || only_type == 'routing'
+          self.display_routing_racks(NexClient::RoutingRack.where(filters).order('aws_region,status'))
+        end
+
+        if !only_type || only_type == 'gateway'
+          self.display_gateway_racks(NexClient::GatewayRack.where(filters).order('aws_region,status'))
+        end
+      end
+
+      def self.display_compute_racks(list)
+        table = Terminal::Table.new title: COMPUTE_RACKS_TITLE, headings: RACKS_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            t.add_row(['compute',e.id,e.aws_region,e.stack,e.status,e.aws_local_ip_address,'-',"#{e.used_pu}/#{e.total_pu}"])
+          end
+        end
+        puts table
+        puts "\n"
+      end
+
+      def self.display_storage_racks(list)
+        table = Terminal::Table.new title: STORAGE_RACKS_TITLE, headings: RACKS_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            t.add_row(['storage',e.id,e.aws_region,'-',e.status,e.aws_local_ip_address,'-',"#{e.used_su}/#{e.total_su}"])
+          end
+        end
+        puts table
+        puts "\n"
+      end
+
+      def self.display_routing_racks(list)
+        table = Terminal::Table.new title: ROUTING_RACKS_TITLE, headings: RACKS_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            t.add_row(['routing',e.id,e.aws_region,'-',e.status,e.aws_local_ip_address,'-','-'])
+          end
+        end
+        puts table
+        puts "\n"
+      end
+
+      def self.display_gateway_racks(list)
+        table = Terminal::Table.new title: GATEWAY_RACKS_TITLE, headings: RACKS_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            t.add_row(['gateway',e.id,e.aws_region,'-',e.status,e.aws_local_ip_address,e.ip_address,'-'])
+          end
+        end
+        puts table
+        puts "\n"
+      end
+    end
+  end
+end

data/lib/nex_client/commands/ssl_certificates.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module NexClient
+  module Commands
+    module SslCertificates
+      extend Helpers
+
+      DOMAINS_TITLE = "SSL Certificates".colorize(:light_yellow)
+      DOMAINS_HEADERS = ['id','cname','origin'].map(&:upcase)
+
+      def self.list(args,opts)
+        filters = {}
+        filters[:'origin.name'] = args.first if args.first.present?
+
+        # Create table
+        list = NexClient::SslCertificate.includes(:origin).where(filters).order('cname')
+        self.display_certs(list)
+      end
+
+      def self.create(args,opts)
+        cert_name,app_name = args
+        app = NexClient::App.find(name: app_name).first
+        app ||= NexClient::CubeInstance.find(name: app_name).first
+
+        # Display error
+        unless app
+          error("Error! Could not find app: #{app_name}")
+          return false
+        end
+
+        # Load or ask certificate content from specified files
+        pubcert = opts.cert.present? ? File.read(opts.cert) : ask("Copy/paste your certificate below:") { |q| q.gather = "" }
+        bundle = opts.bundle.present? ? File.read(opts.bundle) : ask("Copy/paste your cert bundle below:") { |q| q.gather = "" }
+        privkey = opts.privkey.present? ? File.read(opts.privkey) : ask("Copy/paste your cert private key below:") { |q| q.gather = "" }
+
+        cert = NexClient::SslCertificate.new(
+          cname: cert_name,
+          public_cert: pubcert,
+          cert_bundle: bundle,
+          private_key: privkey
+        )
+        cert.relationships.attributes = { origin: { data: { type: app.type, id: app.id } } }
+        cert.save
+
+        # Display errors if any
+        if cert.errors.any?
+          display_record_errors(cert)
+          return false
+        end
+
+        # Display certs
+        self.display_certs(NexClient::SslCertificate.includes(:origin).find(cert.id).first)
+      end
+
+      def self.destroy(args,opts)
+        name = args.first
+        e = NexClient::SslCertificate.find(cname: name).first
+
+        # Display error
+        unless e
+          error("Error! Could not find cert: #{name}")
+          return false
+        end
+
+        # Ask confirmation
+        answer = ask("Enter the name of this cert to confirm: ")
+        unless answer == e.cname
+          error("Aborting deletion...")
+          return false
+        end
+
+        e.destroy
+        success("Successfully destroyed cert: #{name}")
+      end
+
+      def self.display_certs(list)
+        table = Terminal::Table.new title: DOMAINS_TITLE, headings: DOMAINS_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            t.add_row(self.format_record(e))
+          end
+        end
+        puts table
+        puts "\n"
+      end
+
+      def self.format_record(record)
+        origin = self.format_origin(record)
+        [
+          record.id,
+          record.cname,
+          origin
+        ]
+      end
+
+      def self.format_origin(record)
+        return "-" unless record.origin
+        record.origin.name
+      end
+    end
+  end
+end

data/lib/nex_client/commands/users.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module NexClient
+  module Commands
+    module Users
+      extend Helpers
+
+      USERS_TITLE = "Users".colorize(:blue)
+      USERS_HEADERS = ['id','name','email','handle','orgs'].map(&:upcase)
+
+      def self.list(args,opts)
+        filters = {}
+
+        # Stack filter
+        if opts.organization.present?
+          filters[:'organization.handle'] = opts.organization
+        end
+
+        # Create table
+        self.display_users(NexClient::User.includes(:organizations).where(filters).order('handle'))
+      end
+
+      def self.display_users(list)
+        table = Terminal::Table.new title: USERS_TITLE, headings: USERS_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            t.add_row(self.format_record(e))
+          end
+        end
+        puts table
+        puts "\n"
+      end
+
+      def self.format_record(record)
+        orgs = self.format_orgs(record)
+        [
+          record.id,
+          record.first_name,
+          record.email,
+          record.handle,
+          orgs
+        ]
+      end
+
+      def self.format_orgs(record)
+        return "-" unless record.organizations.present?
+        record.organizations.map(&:name).join(',')
+      end
+    end
+  end
+end

data/lib/nex_client/compute_rack.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module NexClient
+  class ComputeRack < BaseResource
+    property :created_at, type: :time
+    property :updated_at, type: :time
+    property :total_pu, type: :int
+    property :available_pu, type: :int
+    property :used_pu, type: :int
+  end
+end

data/lib/nex_client/cube_instance.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module NexClient
+  class CubeInstance < BaseResource
+    property :created_at, type: :time
+    property :updated_at, type: :time
+    property :pu, type: :int
+    property :soa_enabled, type: :boolean
+    property :ssl_enabled, type: :boolean
+    property :persistent_storage, type: :boolean
+    property :port, type: :int
+
+    # PATCH <api_root>/apps/:id/restart
+    custom_endpoint :restart, on: :member, request_method: :patch
+
+    # PATCH <api_root>/apps/:id/start
+    custom_endpoint :start, on: :member, request_method: :patch
+
+    # PATCH <api_root>/apps/:id/stop
+    custom_endpoint :stop, on: :member, request_method: :patch
+  end
+end