nex_client 0.1.0

data/lib/nex_client/commands.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require 'colorize'
+
+module NexClient
+  module Commands
+    autoload :Addons, 'nex_client/commands/addons'
+    autoload :Apps, 'nex_client/commands/apps'
+    autoload :CubeInstances, 'nex_client/commands/cube_instances'
+    autoload :CubeTemplates, 'nex_client/commands/cube_templates'
+    autoload :Domains, 'nex_client/commands/domains'
+    autoload :Helpers, 'nex_client/commands/helpers'
+    autoload :Organizations, 'nex_client/commands/organizations'
+    autoload :Racks, 'nex_client/commands/racks'
+    autoload :SslCertificates, 'nex_client/commands/ssl_certificates'
+    autoload :Users, 'nex_client/commands/users'
+  end
+end

data/lib/nex_client/commands/addons.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+module NexClient
+  module Commands
+    module Addons
+      extend Helpers
+
+      ADDONS_TITLE = "Addons".colorize(:red)
+      ADDONS_HEADERS = ['id','name','status','service','app'].map(&:upcase)
+
+      def self.list(args,opts)
+        filters = {}
+        filters[:status] = opts.status || 'active'
+        filters[:service] = opts.service if opts.service.present?
+
+        # All option
+        filters = {} if opts.all
+
+        # Scope to specific app
+        filters[:'app.name'] = args.first if args.first.present?
+
+        # Create table
+        list = NexClient::Addon.includes(:app).where(filters).order('status')
+        self.display_addons(list)
+      end
+
+      def self.create(args,opts)
+        svc_name,app_name = args
+        app = NexClient::App.find(name: app_name).first
+
+        # Display error
+        unless app
+          error("Error! Could not find app: #{app_name}")
+          return false
+        end
+
+        addon = NexClient::Addon.new(service: svc_name)
+        addon.relationships.attributes = { app: { data: { type: 'apps', id: app.id } } }
+        addon.save
+
+        # Display errors if any
+        if addon.errors.any?
+          display_record_errors(addon)
+          return false
+        end
+
+        # Display app
+        self.display_addons(NexClient::Addon.includes(:app).find(addon.id).first)
+      end
+
+      def self.destroy(args,opts)
+        name = args.first
+        e = NexClient::Addon.find(name: name).first
+
+        # Display error
+        unless e
+          error("Error! Could not find addon: #{name}")
+          return false
+        end
+
+        # Ask confirmation
+        answer = ask("Enter the name of this addon to confirm: ")
+        unless answer == e.name
+          error("Aborting deletion...")
+          return false
+        end
+
+        e.destroy
+        success("Successfully destroyed addon: #{name}")
+      end
+
+      def self.display_addons(list)
+        table = Terminal::Table.new title: ADDONS_TITLE, headings: ADDONS_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)
+        app = self.format_app(record)
+        [
+          record.id,
+          record.name,
+          record.status,
+          record.service,
+          app
+        ]
+      end
+
+      def self.format_app(record)
+        return '-' unless a = record.app
+        a.name
+      end
+    end
+  end
+end

data/lib/nex_client/commands/apps.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+module NexClient
+  module Commands
+    module Apps
+      extend Helpers
+
+      SCALING_DIRECTIONS = [:up,:down]
+      APPS_TITLE = "App Details".colorize(:green)
+      APPS_HEADERS = ['id','name','status','image','ssl','storage','preferred region','nodes','owner'].map(&:upcase)
+
+      VARS_TITLE = "Environment Variables".colorize(:blue)
+      VARS_HEADERS = ['key','value'].map(&:upcase)
+
+      SCM_TITLE = "Source Control Management".colorize(:yellow)
+      SCM_HEADERS = ['provider','repo','branch','last commit'].map(&:upcase)
+
+      def self.list(args,opts)
+        filters = {}
+        filters[:status] = [opts.status || 'active']
+        filters[:ssl_enabled] = opts.ssl if opts.ssl.present?
+        filters[:persistent_storage] = opts.storage if opts.storage.present?
+        filters[:'owner.handle'] = opts.owner if opts.owner.present?
+
+        # All option
+        filters = {} if opts.all
+
+        # Display
+        list = NexClient::App.includes(:owner).where(filters).order('status')
+        self.display_apps(list)
+      end
+
+      def self.info(args,opts)
+        name = args.first
+        e = NexClient::App.includes(:addons,:owner).find(name: name).first
+
+        # Display error
+        unless e
+          error("Error! Could not find app: #{name}")
+          return false
+        end
+
+        # Display app details
+        self.display_apps(e)
+
+        # Display all vars
+        self.display_vars(e.all_vars)
+
+        # Display all vars
+        self.display_scm(e.scm)
+
+        # Display all addons
+        Addons.display_addons(e.addons.select { |a| a.status == 'active'})
+      end
+
+      def self.create(args,opts)
+        image_info = args.first.split(':')
+        attrs = { image: image_info[0], image_tag: image_info[1] }
+
+        # Meta attributes
+        attrs[:ssl_enabled] = !opts.no_ssl if opts.no_ssl.present?
+        attrs[:persistent_storage] = opts.storage if opts.storage.present?
+
+        # Env variables via command line
+        if opts.env.present?
+          attrs[:vars] ||= {}
+          opts.env.each do |e|
+            key,val = e.split('=',2)
+            attrs[:vars][key] = val
+          end
+        end
+
+        # Env variables from file
+        if opts.env_file.present?
+          f = File.read(opts.env_file)
+          attrs[:vars] ||= {}
+          f.split('\n').each do |e|
+            key,val = e.split('=',2)
+            attrs[:vars][key] = val
+          end
+        end
+
+        # Create the app
+        e = NexClient::App.new(attrs)
+
+        # Add owner if specified
+        if opts.owner.present?
+          o = NexClient::Organization.find(handle:opts.owner).first
+          unless o
+            error("Error! Could not find organization: #{opts.owner}")
+            return false
+          end
+          e.relationships.attributes = { owner: { data: { type: 'organizations', id: o.id } } }
+        end
+
+        # Save the resource
+        e.save
+
+        # Display errors if any
+        if e.errors.any?
+          self.display_record_errors(e)
+          return false
+        end
+
+        # Display app
+        self.display_apps(NexClient::App.includes(:owner).find(e.id).first)
+      end
+
+      def self.destroy(args,opts)
+        name = args.first
+        e = NexClient::App.find(name: name).first
+
+        # Display error
+        unless e
+          error("Error! Could not find app: #{name}")
+          return false
+        end
+
+        # Ask confirmation
+        answer = ask("Enter the name of this app to confirm: ")
+        unless answer == e.name
+          error("Aborting deletion...")
+          return false
+        end
+
+        e.destroy
+        success("Successfully destroyed app: #{name}")
+      end
+
+      def self.restart(args,opts)
+        name = args.first
+        e = NexClient::App.find(name: name).first
+
+        # Display error
+        unless e
+          error("Error! Could not find app: #{name}")
+          return false
+        end
+
+        # Perform
+        e.restart
+
+        # Display errors if any
+        if e.errors.any?
+          display_record_errors(e)
+          return false
+        end
+
+        success("Initiated phased restart for app: #{name}...")
+      end
+
+      def self.scale(direction,args,opts)
+        return false unless SCALING_DIRECTIONS.include?(direction.to_sym)
+        name = args.first
+        e = NexClient::App.find(name: name).first
+
+        # Display error
+        unless e
+          error("Error! Could not find app: #{name}")
+          return false
+        end
+
+        # Scaling attributes
+        attrs = {}
+        count = opts.count || 1
+        attrs[:count] = count
+        attrs[:preferred_region] = opts.region if opts.region.present?
+
+        # Perform
+        e.send("scale_#{direction}",{data: { attributes: attrs } })
+
+        # Display errors if any
+        if e.errors.any?
+          display_record_errors(e)
+          return false
+        end
+
+        success("Successfully requested to scale #{name} #{direction} by #{count} #{'node'.pluralize(count)}...")
+      end
+
+      def self.manage_vars(args,opts)
+        name = args.first
+        e = NexClient::App.find(name: name).first
+
+        # Display error
+        unless e
+          error("Error! Could not find app: #{name}")
+          return false
+        end
+
+        # Add/Delete vars
+        if opts.add.present? || opts.delete.present?
+          vars = (e.vars || {}).dup
+
+          # Add vars
+          (opts.add || []).each do |v|
+            key,val = v.split('=',2)
+            vars[key] = val
+          end
+
+          # Delete vars
+          (opts.delete || []).each { |k| vars.delete(k) }
+
+          # Update and reload the resource
+          e.update_attributes(vars: vars)
+          e = NexClient::App.find(e.id).first
+        end
+
+        # Display all vars
+        self.display_vars(e.all_vars)
+      end
+
+      def self.manage_scm(args,opts)
+        name = args.first
+        e = NexClient::App.find(name: name).first
+
+        # Display error
+        unless e
+          error("Error! Could not find app: #{name}")
+          return false
+        end
+
+        # Link SCM
+        if opts.link
+          provider,repo,branch = opts.link.split(':')
+          attrs = { provider: provider, config: { repo: repo, branch: branch } }
+
+          # Update and reload the resource
+          e.link_scm({data: { attributes: attrs } })
+          e = NexClient::App.find(e.id).first
+        end
+
+        # Unlink SCM
+        if !opts.link && opts.unlink
+          # Update and reload the resource
+          e.unlink_scm
+          e = NexClient::App.find(e.id).first
+        end
+
+        # Display all vars
+        self.display_scm(e.scm)
+      end
+
+      def self.display_apps(list)
+        table = Terminal::Table.new title: APPS_TITLE, headings: APPS_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.display_vars(list)
+        table = Terminal::Table.new title: VARS_TITLE, headings: VARS_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            e.each { |k,v| t.add_row([k,v]) }
+          end
+        end
+        puts table
+        puts "\n"
+      end
+
+      def self.display_scm(list)
+        table = Terminal::Table.new title: SCM_TITLE, headings: SCM_HEADERS do |t|
+          [list].flatten.compact.each do |e|
+            t.add_row([e['provider'],e['repo'],e['branch'],e['last_commit'] || '- nothing pushed yet -'])
+          end
+        end
+        puts table
+        puts "\n"
+      end
+
+      def self.format_record(record)
+        owner = self.format_owner(record)
+        node_count = self.format_node_count(record)
+        [
+          record.id,
+          record.name,
+          record.status,
+          record.image,
+          record.ssl_enabled,
+          record.persistent_storage,
+          record.preferred_region,
+          node_count,
+          owner
+        ]
+      end
+
+      def self.format_owner(record)
+        return '-' unless o = record.owner
+        "#{o.type[0]}:#{o.handle}"
+      end
+
+      def self.format_node_count(record)
+        return '-' unless record.node_count && record.max_node_count
+        "#{record.node_count}/#{record.max_node_count}"
+      end
+    end
+  end
+end

data/lib/nex_client/commands/cube_instances.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+module NexClient
+  module Commands
+    module CubeInstances
+      extend Helpers
+
+      CUBES_TITLE = "Cube Instances".colorize(:blue)
+      CUBES_HEADERS = ['id','status','region','ssl','storage','SOA','ip','port','dns','cluster'].map(&:upcase)
+
+      def self.list(args,opts)
+        filters = {}
+        filters[:status] = opts.status || 'running'
+        filters[:soa_enabled] = opts.soa if opts.soa.present?
+        filters[:ssl_enabled] = opts.ssl if opts.ssl.present?
+        filters[:persistent_storage] = opts.storage if opts.storage.present?
+
+        # All option
+        filters = {} if opts.all
+
+        # Identification options
+        filters[:dns] = opts.dns if opts.dns.present?
+        filters[:'app.name'] = opts.app if opts.app.present?
+        filters[:'addon.name'] = opts.addon if opts.addon.present?
+
+        # Create table
+        list = NexClient::CubeInstance.includes(:cluster).where(filters).order('status')
+        self.display_cubes(list)
+      end
+
+      def self.trigger_action(action,args,opts)
+        name = args.first
+        e = NexClient::CubeInstance.find(name: name).first
+
+        # Display error
+        unless e
+          error("Error! Could not find cube: #{name}")
+          return false
+        end
+
+        # Perform
+        e.send(action)
+
+        # Display errors if any
+        if e.errors.any?
+          display_record_errors(e)
+          return false
+        end
+
+        success("Initiated #{action} for cube #{name}...")
+      end
+
+      def self.display_cubes(list)
+        table = Terminal::Table.new title: CUBES_TITLE, headings: CUBES_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)
+        dns = self.format_dns(record)
+        cluster = self.format_cluster(record)
+        [
+          record.id,
+          record.status,
+          record.region,
+          record.ssl_enabled,
+          record.persistent_storage,
+          record.soa_enabled,
+          record.ip_address || '-',
+          record.port || '-',
+          dns,
+          cluster
+        ]
+      end
+
+      def self.format_dns(record)
+        record.dns || '-'
+      end
+
+      def self.format_cluster(record)
+        return '-' unless o = record.cluster
+        "#{o.type.singularize}:#{o.name}"
+      end
+    end
+  end
+end