civo_cli 0.1.0 → 0.1.1

data/lib/civo_cli.rb

@@ -1,6 +1,67 @@
 require "civo_cli/version"
 
-module CivoCli
+require "civo"
+require "json"
+require "thor"
+require "terminal-table"
+require 'colorize'
+Dir[File.join(__dir__, '*.rb')].each { |file| require file }
+
+module CivoCLI
   class Error < StandardError; end
-  # Your code goes here...
+
+  class Main < Thor
+    desc "apikey", "manage API keys stored in the client"
+    subcommand "apikey", CivoCLI::APIKey
+    map "apikeys" => "apikey"
+
+    desc "blueprint", "manage blueprints"
+    subcommand "blueprint", CivoCLI::Blueprint
+    map "blueprints" => "blueprint"
+
+    desc "domain", "manage DNS domains"
+    subcommand "domain", CivoCLI::Domain
+    map "domains" => "domain"
+
+    desc "firewall", "manage firewalls"
+    subcommand "firewall", CivoCLI::Firewall
+    map "firewalls" => "firewall"
+
+    desc "instance", "manage instances"
+    subcommand "instance", CivoCLI::Instance
+    map "instances" => "instance"
+
+    desc "network", "manage networks"
+    subcommand "network", CivoCLI::Network
+    map "networks" => "network"
+
+    desc "quota", "view the quota"
+    subcommand "quota", CivoCLI::Quota
+    map "quotas" => "quota"
+
+    desc "region", "manage regions"
+    subcommand "region", CivoCLI::Region
+    map "regions" => "region"
+
+    desc "size", "manage sizes"
+    subcommand "size", CivoCLI::Size
+    map "sizes" => "size"
+
+    desc "snapshot", "manage snapshots"
+    subcommand "snapshot", CivoCLI::Snapshot
+    map "snapshots" => "snapshot"
+
+    desc "sshkey", "manage uploaded SSH keys"
+    subcommand "sshkey", CivoCLI::SSHKey
+    map "sshkeys" => "sshkey"
+
+    desc "template", "manage templates"
+    subcommand "template", CivoCLI::Template
+    map "templates" => "template"
+
+    desc "volume", "manage volumes"
+    subcommand "volume", CivoCLI::Volume
+    map "volumes" => "volume"
+
+  end
 end

data/lib/config.rb

@@ -0,0 +1,74 @@
+module CivoCLI
+  class Config
+    def self.get_apikeys
+      current["apikeys"]
+    end
+
+    def self.get_apikey(key)
+      current["apikeys"][key]
+    end
+
+    def self.get_current_apikey
+      current["apikeys"][get_current_apikey_name]
+    end
+
+    def self.get_current_apikey_name
+      get_meta(:current_apikey)
+    end
+
+    def self.set_current_apikey_name(name)
+      set_meta(:current_apikey, name)
+    end
+
+    def self.set_apikey(key, value)
+      current["apikeys"][key] = value
+      save
+    end
+
+    def self.delete_apikey(key)
+      current["apikeys"].delete(key)
+      if get_current_apikey_name == key
+        if get_apikeys.any?
+          set_current_apikey_name(get_apikeys.keys.first)
+        else
+          set_current_apikey_name(nil)
+        end
+      end
+    end
+
+    def self.get_meta(key)
+      current["meta"].transform_keys{ |key| key.to_sym rescue key }[key]
+    end
+
+    def self.set_meta(key, value)
+      current["meta"][key.to_s] = value
+      save
+    end
+
+    def self.current
+      @config ||= JSON.parse(File.read(filename))
+    end
+
+    def self.reset
+      @config = nil
+    end
+
+    def self.save
+      File.write(filename, @config.to_json)
+    end
+
+    def self.filename
+      "#{ENV['HOME']}/.civo.json"
+    end
+
+    def self.set_api_auth
+      ENV["CIVO_API_VERSION"] = "2"
+      ENV["CIVO_TOKEN"] = CivoCLI::Config.get_current_apikey
+      if ENV["CIVO_TOKEN"].nil? || ENV["CIVO_TOKEN"] == ""
+        puts "#{"Unable to connect:".colorize(:red)} No valid API key is set"
+        exit 1
+      end
+      ENV["CIVO_URL"] = CivoCLI::Config.get_meta(:url) || "https://api.civo.com"
+    end
+  end
+end

data/lib/domain.rb

@@ -0,0 +1,5 @@
+module CivoCLI
+  class Domain < Thor
+
+  end
+end

data/lib/firewall.rb

@@ -0,0 +1,5 @@
+module CivoCLI
+  class Firewall < Thor
+
+  end
+end

data/lib/instance.rb

@@ -0,0 +1,115 @@
+module CivoCLI
+  class Instance < Thor
+    desc "list", "list all instances"
+    def list
+      CivoCLI::Config.set_api_auth
+      rows = []
+      sizes = Civo::Size.all.items
+      Civo::Instance.all.items.each do |instance|
+        size_name = sizes.detect {|s| s.name == instance.size}&.nice_name
+        rows << [instance.id, instance.hostname, size_name, instance.region, instance.public_ip, instance.status]
+      end
+      puts Terminal::Table.new headings: ['ID', 'Hostname', 'Size', 'Region', 'Public IP', 'Status'], rows: rows
+    end
+
+    if CivoCLI::Config.get_meta("admin")
+      desc "", ""
+      def high_cpu
+        # {ENV["CIVO_API_VERSION"] || "1"}/instances/high_cpu"
+      end
+    end
+
+    desc "", ""
+    def find
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id", requires: [:id]
+    end
+
+    desc "", ""
+    def create
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances", requires: [:hostname, :size, :region],
+      # defaults: {public_ip: true, initial_user: "civo"}
+    end
+
+    desc "", ""
+    def tags
+
+    end
+
+    desc "", ""
+    def update
+
+    end
+
+    desc "", ""
+    def remove
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id", requires: [:id], send_delete_body: true
+    end
+
+    desc "", ""
+    def reboot
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/reboots", requires: [:id]
+    end
+
+    desc "", ""
+    def hard_reboot
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/hard_reboots", requires: [:id]
+    end
+
+    desc "", ""
+    def soft_reboot
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/soft_reboots", requires: [:id]
+    end
+
+    desc "", ""
+    def console
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/console", requires: [:id]
+    end
+
+    desc "", ""
+    def rebuild
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/rebuild", requires: [:id]
+    end
+
+    desc "", ""
+    def stop
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/stop", requires: [:id]
+    end
+
+    desc "", ""
+    def start
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/start", requires: [:id]
+    end
+
+    desc "", ""
+    def upgrade
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/resize", requires: [:size, :id]
+    end
+
+    desc "", ""
+    def restore
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/restore", requires: [:snapshot, :id]
+    end
+
+    desc "", ""
+    def move_ip
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/ip/:ip", requires: [:ip, :id]
+    end
+
+    desc "", ""
+    def rescue
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/rescue", requires: [:id]
+    end
+
+    desc "", ""
+    def unrescue
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/unrescue", requires: [:id]
+    end
+
+    desc "", ""
+    def firewall
+      # {ENV["CIVO_API_VERSION"] || "1"}/instances/:id/firewall", requires: [:firewall_id, :id]
+    end
+
+    default_task :list
+  end
+end

data/lib/network.rb

@@ -0,0 +1,43 @@
+module CivoCLI
+  class Network < Thor
+    desc "list", "list all networks"
+    def list
+      CivoCLI::Config.set_api_auth
+      rows = []
+      Civo::Network.all.items.each do |network|
+        if network.default
+          rows << [network.id, network.label, network.cidr, "<====="]
+        else
+          rows << [network.id, network.label, network.cidr, ""]
+        end
+      end
+      puts Terminal::Table.new headings: ['ID', 'Label', 'CIDR', 'Default?'], rows: rows
+    end
+
+    desc "create LABEL", "create a new private network called LABEL"
+    def create(label)
+      CivoCLI::Config.set_api_auth
+      network = Civo::Network.create(label: label)
+      puts "Create a private network called #{label.colorize(:green)} with ID #{network.id.colorize(:green)}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "new" => "create"
+
+    desc "remove ID", "remove the network ID"
+    def remove(id)
+      CivoCLI::Config.set_api_auth
+      network = Civo::Network.all.items.detect {|key| key.id == id}
+      Civo::Network.remove(id: id)
+      puts "Removed the network #{network.label.colorize(:green)} with ID #{network.id.colorize(:green)}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "delete" => "remove", "rm" => "remove"
+
+    default_task :list
+
+  end
+end

data/lib/quota.rb

@@ -0,0 +1,69 @@
+module CivoCLI
+  class Quota < Thor
+    desc "show", "show the current quota and usage"
+    def show
+      CivoCLI::Config.set_api_auth
+      rows = []
+      quota = Civo::Quota.current
+      if quota.instance_count_usage >= (quota.instance_count_limit * 0.8)
+        rows << ["Instances", quota.instance_count_usage.to_s.colorize(:red), quota.instance_count_limit]
+      else
+        rows << ["Instances", quota.instance_count_usage, quota.instance_count_limit]
+      end
+      if quota.cpu_core_usage >= (quota.cpu_core_limit * 0.8)
+        rows << ["CPU cores", quota.cpu_core_usage.to_s.colorize(:red), quota.cpu_core_limit]
+      else
+        rows << ["CPU cores", quota.cpu_core_usage, quota.cpu_core_limit]
+      end
+      if quota.ram_mb_usage >= (quota.ram_mb_limit * 0.8)
+        rows << ["RAM MB", quota.ram_mb_usage.to_s.colorize(:red), quota.ram_mb_limit]
+      else
+        rows << ["RAM MB", quota.ram_mb_usage, quota.ram_mb_limit]
+      end
+      if quota.disk_gb_usage >= (quota.disk_gb_limit * 0.8)
+        rows << ["Disk GB", quota.disk_gb_usage.to_s.colorize(:red), quota.disk_gb_limit]
+      else
+        rows << ["Disk GB", quota.disk_gb_usage, quota.disk_gb_limit]
+      end
+      if quota.disk_volume_count_usage >= (quota.disk_volume_count_limit * 0.8)
+        rows << ["Volumes", quota.disk_volume_count_usage.to_s.colorize(:red), quota.disk_volume_count_limit]
+      else
+        rows << ["Volumes", quota.disk_volume_count_usage, quota.disk_volume_count_limit]
+      end
+      if quota.disk_snapshot_count_usage >= (quota.disk_snapshot_count_limit * 0.8)
+        rows << ["Snapshots", quota.disk_snapshot_count_usage.to_s.colorize(:red), quota.disk_snapshot_count_limit]
+      else
+        rows << ["Snapshots", quota.disk_snapshot_count_usage, quota.disk_snapshot_count_limit]
+      end
+      if quota.public_ip_address_usage >= (quota.public_ip_address_limit * 0.8)
+        rows << ["Public IPs", quota.public_ip_address_usage.to_s.colorize(:red), quota.public_ip_address_limit]
+      else
+        rows << ["Public IPs", quota.public_ip_address_usage, quota.public_ip_address_limit]
+      end
+      if quota.subnet_count_usage >= (quota.subnet_count_limit * 0.8)
+        rows << ["Subnets", quota.subnet_count_usage.to_s.colorize(:red), quota.subnet_count_limit]
+      else
+        rows << ["Subnets", quota.subnet_count_usage, quota.subnet_count_limit]
+      end
+      if quota.network_count_usage >= (quota.network_count_limit * 0.8)
+        rows << ["Private networks", quota.network_count_usage.to_s.colorize(:red), quota.network_count_limit]
+      else
+        rows << ["Private networks", quota.network_count_usage, quota.network_count_limit]
+      end
+      if quota.security_group_usage >= (quota.security_group_limit * 0.8)
+        rows << ["Firewalls", quota.security_group_usage.to_s.colorize(:red), quota.security_group_limit]
+      else
+        rows << ["Firewalls", quota.security_group_usage, quota.security_group_limit]
+      end
+      if quota.security_group_rule_usage >= (quota.security_group_rule_limit * 0.8)
+        rows << ["Firewall rules", quota.security_group_rule_usage.to_s.colorize(:red), quota.security_group_rule_limit]
+      else
+        rows << ["Firewall rules", quota.security_group_rule_usage, quota.security_group_rule_limit]
+      end
+      puts Terminal::Table.new headings: ["Item", "Usage", "Limit"], rows: rows
+      puts "Any items in #{"red".to_s.colorize(:red)} are at least 80% of your limit"
+    end
+
+    default_task :show
+  end
+end

data/lib/region.rb

@@ -0,0 +1,15 @@
+module CivoCLI
+  class Region < Thor
+    desc "list", "List all regions available for selection"
+    def list
+      CivoCLI::Config.set_api_auth
+      rows = []
+      Civo::Region.all.items.each do |region|
+        rows << [region.code]
+      end
+      puts Terminal::Table.new headings: ['Code'], rows: rows
+    end
+
+    default_task :list
+  end
+end

data/lib/size.rb

@@ -0,0 +1,16 @@
+module CivoCLI
+  class Size < Thor
+    desc "list", "List all sizes available for selection"
+    def list
+      CivoCLI::Config.set_api_auth
+      rows = []
+      Civo::Size.all.items.select{|s| s.selectable }.each do |size|
+        rows << [size.name, size.description, size.cpu_cores, size.ram_mb, size.disk_gb]
+      end
+      puts Terminal::Table.new headings: ['Name', 'Description', 'CPU', 'RAM (MB)', 'Disk (GB)'], rows: rows
+    end
+
+    default_task :list
+
+  end
+end

data/lib/snapshot.rb

@@ -0,0 +1,43 @@
+module CivoCLI
+  class Snapshot < Thor
+    desc "list", "list all snapshots"
+    def list
+      CivoCLI::Config.set_api_auth
+      rows = []
+      Civo::Snapshot.all.items.each do |snapshot|
+        rows << [snapshot.id, snapshot.name, snapshot.state, snapshot.size_gb, (snapshot.cron_timing || "One-off")]
+      end
+      puts Terminal::Table.new headings: ['ID', 'Name', 'State', "Size (GB)", "Cron"], rows: rows
+    end
+
+    option "cron", type: :string, desc: "The timing of when to take/repeat in cron format", aliases: ["-c"], banner: "CRON_TIMING"
+    desc "create NAME INSTANCE_ID [-c '0 * * * *']", "create a snapshot called NAME from instance INSTANCE_ID"
+    def create(name, instance_id)
+      CivoCLI::Config.set_api_auth
+      puts options.inspect
+      params = {name: name, instance_id: instance_id}
+      params[:cron_timing] = options["cron"] unless options["cron"].nil?
+      snapshot = Civo::Snapshot.create(params)
+      puts "Created snapshot #{name.colorize(:green)} with ID #{snapshot.id.colorize(:green)} #{"with cron timing #{options["cron"].colorize(:green)}" unless options["cron"].nil?}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "new" => "create"
+
+    desc "remove ID", "remove the snapshot ID"
+    def remove(id)
+      CivoCLI::Config.set_api_auth
+      snapshot = Civo::Snapshot.all.items.detect {|key| key.id == id}
+      Civo::Snapshot.remove(id: id)
+      puts "Removed snapshot #{snapshot.name.colorize(:green)} with ID #{snapshot.id.colorize(:green)}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "delete" => "remove", "rm" => "remove"
+
+    default_task :list
+
+  end
+end

data/lib/sshkey.rb

@@ -0,0 +1,38 @@
+module CivoCLI
+  class SSHKey < Thor
+    desc "list", "list all SSH keys"
+    def list
+      CivoCLI::Config.set_api_auth
+      rows = []
+      Civo::SshKey.all.items.each do |key|
+        rows << [key.id, key.name, key.fingerprint]
+      end
+      puts Terminal::Table.new headings: ['ID', 'Name', 'Fingerprint'], rows: rows
+    end
+
+    desc "upload NAME FILENAME", "upload the SSH public key in FILENAME to a new key called NAME"
+    def upload(name, filename)
+      CivoCLI::Config.set_api_auth
+      ssh_key = Civo::SshKey.create(name: name, public_key: File.read(filename))
+      puts "Uploaded SSH key #{name.colorize(:green)} with ID #{ssh_key.id.colorize(:green)}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "create" => "upload", "new" => "upload"
+
+    desc "remove ID", "remove the SSH public key with ID"
+    def remove(id)
+      CivoCLI::Config.set_api_auth
+      ssh_key = Civo::SshKey.all.items.detect {|key| key.id == id}
+      Civo::SshKey.remove(id: id)
+      puts "Removed SSH key #{ssh_key.name.colorize(:green)} with ID #{ssh_key.id.colorize(:green)}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "delete" => "remove", "rm" => "remove"
+
+    default_task :list
+  end
+end

data/lib/template.rb

@@ -0,0 +1,96 @@
+module CivoCLI
+  class Template < Thor
+    desc "list", "list all templates"
+    def list
+      CivoCLI::Config.set_api_auth
+      rows = []
+      Civo::Template.all.items.each do |template|
+        rows << [template.id, template.name, template.image_id, template.volume_id, template.default_username]
+      end
+      puts Terminal::Table.new headings: ['ID', 'Name', 'Image ID', 'Volume ID', "Default Username"], rows: rows
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+
+    desc "show ID", "show the details for a single template"
+    def show(id)
+      CivoCLI::Config.set_api_auth
+      template = Civo::Template.details(id)
+      puts "               ID: #{template.id}"
+      puts "             Code: #{template.code}"
+      puts "             Name: #{template.name}"
+      puts "         Image ID: #{template.image_id}"
+      puts "        Volume ID: #{template.volume_id}"
+      puts "Short Description: #{template.short_description}"
+      puts "      Description: #{template.description}"
+      puts " Default Username: #{template.default_username}"
+      puts ""
+      puts "-" * 29 + "CLOUD CONFIG" + "-" * 29
+      puts template.cloud_config
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+
+    option "cloud-init-file", type: :string, desc: "The filename of a file to be used as user-data/cloud-init", aliases: ["-c"], banner: "CLOUD_INIT_FILENAME"
+    option :description, type: :string, desc: "A full/long multiline description", aliases: ["-d"], banner: "DESCRIPTION"
+    option "image-id", type: :string, desc: "The glance ID of the base filesystem image", aliases: ["-i"], banner: "IMAGE_ID"
+    option "volume-id", type: :string, desc: "The volume ID of the base filesystem volume", aliases: ["-v"], banner: "VOLUME_ID"
+    option :name, type: :string, desc: "A nice name to be used for the template", aliases: ["-n"], banner: "NICE_NAME"
+    option "short-description", type: :string, desc: "A one line short summary of the template", aliases: ["-s"], banner: "SUMMARY"
+    desc "update ID", "update the template with ID"
+    def update(id)
+      CivoCLI::Config.set_api_auth
+      params = {id: id}
+      params[:cloud_config] = File.read(options["cloud-init-file"]) unless options["cloud-init-file"].nil?
+      params[:image_id] = options["image-id"] unless options["image-id"].nil?
+      params[:volume_id] = options["volume-id"] unless options["volume-id"].nil?
+      params[:description] = options["description"] unless options["description"].nil?
+      params[:name] = options["name"] unless options["name"].nil?
+      params[:short_description] = options["short-description"] unless options["short-description"].nil?
+      Civo::Template.save(params)
+      template = Civo::Template.details(id)
+      puts "Updated template #{template.name.colorize(:green)}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+
+    option "cloud-init-file", type: :string, desc: "The filename of a file to be used as user-data/cloud-init", aliases: ["-c"], banner: "CLOUD_INIT_FILENAME"
+    option :description, type: :string, desc: "A full/long multiline description", aliases: ["-d"], banner: "DESCRIPTION"
+    option "image-id", type: :string, desc: "The glance ID of the base filesystem image", aliases: ["-i"], banner: "IMAGE_ID"
+    option "volume-id", type: :string, desc: "The volume ID of the base filesystem volume", aliases: ["-v"], banner: "VOLUME_ID"
+    option :name, type: :string, desc: "A nice name to be used for the template", aliases: ["-n"], banner: "NICE_NAME"
+    option "short-description", type: :string, desc: "A one line short summary of the template", aliases: ["-s"], banner: "SUMMARY"
+    desc "create", "create a new template"
+    def create
+      CivoCLI::Config.set_api_auth
+      params = {}
+      params[:cloud_config] = File.read(options["cloud-init-file"]) unless options["cloud-init-file"].nil?
+      params[:image_id] = options["image-id"] unless options["image-id"].nil?
+      params[:volume_id] = options["volume-id"] unless options["volume-id"].nil?
+      params[:description] = options["description"] unless options["description"].nil?
+      params[:name] = options["name"] unless options["name"].nil?
+      params[:short_description] = options["short-description"] unless options["short-description"].nil?
+      template = Civo::Template.create(params)
+      puts "Created template #{template.name.colorize(:green)} with ID #{template.id.colorize(:green)}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "new" => "create"
+
+    desc "remove ID", "remove the template with ID"
+    def remove(id)
+      CivoCLI::Config.set_api_auth
+      Civo::Template.remove(id)
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "delete" => "remove", "rm" => "remove"
+
+    default_task :list
+  end
+end