civo_cli 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d62448379809416dbb023c5af87507ea6d678b099919e82a4ea0b5c3edf5f23f
-  data.tar.gz: dadd6536e7152e2b8d40495aa4b0cccc9e57afae69dac56505d2dfd8227073c0
+  metadata.gz: 024560b523d64e630b4171c5246c0e346a4b43ce0255f88891a2e38a6f6638d9
+  data.tar.gz: 13c84db2adba712473576272c6110703ab980105aa7a9d42c0aedcdc0f41d1b2
 SHA512:
-  metadata.gz: fa11fc73c7c3cecafc93757f7b4273a9a544998b3dee4c9a33feadc93138bb998f7b64ab43dee1a4e3eb56a1e90f8c2c0c9f6272ca0b36aab52163123a6e97dc
-  data.tar.gz: c047daf2274eeb5c9eddc595f80c8d52764f317a3bb90b8bfad4a70e507f8245529699eb3b4a9c17f59fcc0d1c13fe840d81eddebb4a4b9c9f1fdfdc007ea77c
+  metadata.gz: 2461ec652f57b9543781216fb8f65998673fa3a69b2ededcd2d655f232681bc320446ca5f975b0206b043472d964df6a7dd51f80d5dc1d356107ffa79add87a3
+  data.tar.gz: 1d0071b595864730781b8e0646b89382d47d95318dc424704587331b34c043e03c2827b17fbf68bba3d14215d4c3688dabf2346a8d7957ca518d53ab28ae2e57

data/CHANGELOG.md

@@ -3,7 +3,14 @@ All notable changes to the Civo CLI will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.3.8] - 2019-08-12
+## [0.3.10] - 2019-08-19
+### Added
+- Alias for `instance public_ip` method as `instance ip`
+
+### Fixed
+- File require issues on Debian Jessie preventing gem from running
+
+## [0.3.9] - 2019-08-12
 ### Added
 - Time taken for a `create` command appended with `--wait`.
 ### Fixed

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    civo_cli (0.3.9)
+    civo_cli (0.3.10)
       bundler (~> 1.17)
       civo (>= 1.2.5)
       colorize

data/README.md

@@ -14,6 +14,7 @@ Civo CLI is a tool to manage your [Civo.com](https://www.civo.com) account from
 - [Domains and Domain Records](#domains-and-domain-records)
 - [Firewalls](#firewalls)
 - [Networks](#networks)
+- [Load Balancers](#load-balancers)
 - [Quota](#quota)
 - [Sizes](#sizes)
 - [Snapshots](#snapshots)
@@ -480,6 +481,47 @@ $ civo network remove 74b69006-ea59-46a0-96c4-63f5bfa290e1
 Removed the network cli-demo with ID 74b69006-ea59-46a0-96c4-63f5bfa290e1
 ```
 
+## Load Balancers
+#### Introduction
+Civo supports load balancing for your instances, allowing you to spread web traffic between them to maximise availability. You can view details about load balancers you may have running, create new oness, update information and even remove them from the command line. 
+
+#### Viewing Load Balancers
+You can list currently-active load balancers by calling `civo loadbalancer list`. This will draw a table detailing the unique ID, hostname, protocol, port, TLS certificate information, backend check path and connection information.
+
+#### Creating Load Balancers
+Create a new load balancer by calling `civo loadbalancer create` as well as any options you provide. The options are:
+* `hostname` -  A valid hostname for your load balancer. Defaults to `loadbalancer-[uuid].civo.com`.
+* `protocol` - Either `http` or `https`. If you specify `https` then you must also provide the next two fields.
+* `tls_certificate` - TLS certificate in Base64-encoded PEM. Required if `--protocol` is `https`.
+* `tls_key` - TLS key in Base64-encoded PEM. Required if `--protocol` is `https`.
+* `max_request_size` - Maximum request content size, in MB. Defaults to 20.
+* `port` - Listening port. Defaults to 80 to match default `http` protocol.
+* `policy` - Traffic management policy. One of: `least_conn` (sends new requests to the least busy server), `random` (sends new requests to a random backend), `round_robin` (sends new requests to the next backend in order), `ip_hash` (sends requests from a given IP address to the same backend), default is "random".
+* `health_check_path` - URL to check for a valid (2xx/3xx) HTTP status on the backends. Defaults to `/`.
+* `fail_timeout` - Timeout in seconds to consider a backend to have failed. Defaults to `30`.
+* `max_conns` - Maximum concurrent connections to each backend. Defaults to `10`.
+* `ignore_invalid_backend_tls` - Should self-signed/invalid certificates be ignored from backend servers? Defaults to `true`.
+* `backend` - Specify a backend instance to associate with the load balancer. Takes `instance_id`, `protocol` and `port` in the format `--backend=instance_id: instance-id protocol: http port: 80`.
+```
+$ civo loadbalancer create
+Created a new Load Balancer with hostname loadbalancer-01da06bc-40ef-4d4c-bb68-d0765d288b54.civo.com
+```
+
+#### Updating Load Balancers
+Updating an existing load balancer takes the same options as creation, with the syntax being `civo loadbalancer update ID [options]`. For example, we can update the hostname of the load balancer created above using `--hostname`:
+```
+$ civo loadbalancer update 01da06bc-40ef-4d4c-bb68-d0765d288b54 --hostname="civo-demo-loadbalancer.civo.com"
+Updated Load Balancer
+```
+
+#### Removing Load Balancers
+Removing a load balancer is simple - simply call `civo loadbalancer remove loadbalancer_id`. Please note that this change is immediate:
+
+```
+$ civo loadbalancer remove 01da06bc-40ef-4d4c-bb68-d0765d288b54
+Removed the load balancer civo-demo-loadbalancer.civo.com with ID 01da06bc-40ef-4d4c-bb68-d0765d288b54
+```
+
 ## Quota
 All customers joining Civo will have a default quota applied to their account. The quota has nothing to do with charges or payments, but with the limits on the amount of simultaneous resources you can use. You can view the state of your quota at any time by running `civo quota`. Here is my current quota usage at the time of writing:
 ```

data/lib/civo_cli.rb

@@ -5,6 +5,7 @@ require "thor"
 require "terminal-table"
 require 'colorize'
 require 'config'
+require 'namegenerator'
 Dir[File.join(__dir__, '*.rb')].each { |file| require file }
 
 module CivoCLI
@@ -39,6 +40,10 @@ module CivoCLI
     subcommand "kubernetes", CivoCLI::Kubernetes
     map "k8s" => "kubernetes"
 
+    desc "loadbalancer", "manage load balancers"
+    subcommand "loadbalancer", CivoCLI::LoadBalancer
+    map "loadbalancers" => "loadbalancer"
+
     desc "network", "manage networks"
     subcommand "network", CivoCLI::Network
     map "networks" => "network"

data/lib/civo_cli/version.rb

@@ -1,3 +1,3 @@
 module CivoCLI
-  VERSION = "0.3.9"
+  VERSION = "0.3.10"
 end

data/lib/instance.rb

@@ -140,7 +140,8 @@ module CivoCLI
 
       if options[:wait]
         print "Building new instance #{hostname}: "
-
+        timer = CivoCLI::Timer.new
+        timer.start_timer
         spinner = CivoCLI::Spinner.spin(instance: @instance) do |s|
           Civo::Instance.all.items.each do |instance|
             if instance.id == @instance.id && instance.status == 'ACTIVE'
@@ -149,8 +150,8 @@ module CivoCLI
           end
           s[:final_instance]
         end
-
-        puts "\b Done\nCreated instance #{spinner[:final_instance].hostname.colorize(:green)} - #{spinner[:final_instance].initial_user}@#{spinner[:final_instance].public_ip}"
+        timer.end_timer
+        puts "\b Done\nCreated instance #{spinner[:final_instance].hostname.colorize(:green)} - #{spinner[:final_instance].initial_user}@#{spinner[:final_instance].public_ip} in #{Time.at(timer.time_elapsed).utc.strftime("%M min %S sec")}"
       else
         puts "Created instance #{hostname.colorize(:green)}"
       end
@@ -325,6 +326,8 @@ module CivoCLI
       puts e.result.reason.colorize(:red)
       exit 1
     end
+    map "ip" => "public_ip"
+
 
     desc "password ID/HOSTNAME", "Show the default user password for instance with ID/HOSTNAME"
     option :quiet, type: :boolean, aliases: '-q'

data/lib/kubernetes.rb

@@ -90,6 +90,8 @@ module CivoCLI
       @cluster = Civo::Kubernetes.create(name: name, target_nodes_size: options[:size], num_target_nodes: options[:nodes])
 
       if options[:wait]
+        timer = CivoCLI::Timer.new
+        timer.start_timer
         print "Building new Kubernetes cluster #{name.colorize(:green)}: "
 
         spinner = CivoCLI::Spinner.spin(instance: @instance) do |s|
@@ -101,7 +103,8 @@ module CivoCLI
           s[:final_cluster]
         end
 
-        puts "\b Done\nCreated Kubernetes cluster #{spinner[:final_cluster].name.colorize(:green)}"
+        timer.end_timer
+        puts "\b Done\nCreated Kubernetes cluster #{name.colorize(:green)} in #{Time.at(timer.time_elapsed).utc.strftime("%M min %S sec")}"
       elsif !options[:wait] && options[:save]
         puts "Creating Kubernetes cluster #{name.colorize(:green)}. Can only save configuration once cluster is created."
       else

data/lib/loadbalancer.rb

@@ -0,0 +1,145 @@
+module CivoCLI
+  class LoadBalancer < Thor
+    desc "list", "list all load balancers"
+    def list
+      CivoCLI::Config.set_api_auth
+      rows = []
+      Civo::LoadBalancer.all.items.each do |loadbalancer|
+        rows << [loadbalancer.id, loadbalancer.hostname, loadbalancer.protocol, loadbalancer.port, loadbalancer.tls_certificate, loadbalancer.tls_key, loadbalancer.policy, loadbalancer.health_check_path, loadbalancer.fail_timeout, loadbalancer.max_conns, loadbalancer.ignore_invalid_backend_tls, loadbalancer.backends.items.map(&:instance_id).join(", ")]
+      end
+      
+      puts Terminal::Table.new headings: ['ID', 'Hostname', 'Protocol', 'Port', "TLS\nCert", 'TLS key', 'Policy', "Health Check\nPath", "Fail\nTimeout", "Max.\nConnections", "Ignore Invalid\nBackend TLS?", 'Backends'], rows: rows
+    end
+    map "ls" => "list", "all" => "list"
+
+
+    desc "create [OPTIONS]", "create a new load balancer with options"
+    option :hostname, banner: 'hostname', aliases: '--name'
+    option :protocol, default: 'http', banner: 'http | https'
+    option :tls_certificate, banner: 'base64 PEM'
+    option :tls_key, banner: 'base64 PEM'
+    option :port, default: 80, type: :numeric, banner: 'listen port'
+    option :max_request_size, default: 20, type: :numeric, banner: 'MegaBytes'
+    option :policy, default: 'random', banner: 'least_conn | random | round_robin | ip_hash'
+    option :health_check_path, default: '/', banner: 'URL', alias: 'healthpath'
+    option :fail_timeout, default: 30, type: :numeric, banner: 'seconds'
+    option :max_conns, default: 10, type: :numeric, banner: 'connections'
+    option :ignore_invalid_backend_tls, default: true, type: :boolean
+    option :backend, default: {}, type: :hash
+    long_desc <<-LONGDESC
+      Create a new load balancer with hostname (randomly assigned if blank), and supplied options:
+      \x5--hostname=<hostname> - If not supplied, will be in format loadbalancer-uuid.civo.com
+      \x5--protocol=<http | https> - Either http or https. If you specify https then you must also provide the next two fields
+      \x5--tls_certificate=<base64 PEM> - TLS certificate in Base64-encoded PEM. Required if --protocol is https
+      \x5--tls_key=<base64 PEM> - TLS key in Base64-encoded PEM. Required if --protocol is https
+      \x5--port=<n> - Port to listen on. Defaults to 80 to match default protocol
+      \x5--max_request_size=<nn> - Maximum request content size, in MB
+      \x5--policy=<least_conn | random | round_robin | ip_hash> - Balancing policy to choose backends
+      \x5--health_check_path=<URL> - Which URL to use to determine if backend status is OK (2xx/3xx status)
+      \x5--fail_timeout=<seconds> - Backend timeout in seconds
+      \x5--max_conns=<connections> - Maximum concurrent connections to each backend
+      \x5--ignore_invalid_backend_tls=<true | false> - Should self-signed/invalid certificates be ignored from the backend servers?
+      \x5--backend=<instance_id:instance_id protocol:http | https port:number> - A backend instance, with the instance ID, desired protocol and port number specified.
+      LONGDESC
+    def create(*args)
+      CivoCLI::Config.set_api_auth
+      backends = {}
+      options[:backend].each do | key, value |
+        backends[key] = value
+      end
+      backendarray = []
+      backendarray << backends
+      loadbalancer = Civo::LoadBalancer.create(hostname: options[:hostname] ||= nil, 
+        protocol: options[:protocol], 
+        tls_certificate: options[:tls_certificate], 
+        tls_key: options[:tls_key], 
+        port: options[:port], 
+        max_request_size: options[:max_request_size], 
+        policy: options[:policy], 
+        health_check_path: options[:health_check_path], 
+        fail_timeout: options[:fail_timeout], 
+        max_conns: options[:max_conns], 
+        ignore_invalid_backend_tls: options[:ignore_invalid_backend_tls], 
+        backends: backendarray)
+      
+      puts "Created a new Load Balancer with hostname #{loadbalancer.hostname.colorize(:green)}"
+      
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "new" => "create"
+
+    desc "update ID [OPTIONS]", "update the load balancer ID with options provided"
+    option :hostname, banner: 'hostname', aliases: '--name'
+    option :protocol, default: 'http', banner: 'http | https'
+    option :tls_certificate, banner: 'base64 PEM'
+    option :tls_key, banner: 'base64 PEM'
+    option :port, lazy_default: 80, type: :numeric, banner: 'listen port'
+    option :max_request_size, lazy_default: 20, type: :numeric, banner: 'MegaBytes'
+    option :policy, lazy_default: 'random', banner: 'least_conn | random | round_robin | ip_hash'
+    option :health_check_path, lazy_default: '/', banner: 'URL', alias: 'healthpath'
+    option :fail_timeout, lazy_default: 30, type: :numeric, banner: 'seconds'
+    option :max_conns, lazy_default: 10, type: :numeric, banner: 'connections'
+    option :ignore_invalid_backend_tls, lazy_default: true, type: :boolean
+    option :backend, default: {}, type: :hash
+    long_desc <<-LONGDESC
+      Update a load balancer with ID provided, and any of the following options:
+      \x5--hostname=<hostname> - New hostname
+      \x5--protocol=<http | https> - Either http or https. If you specify https then you must also provide the next two fields
+      \x5--tls_certificate=<base64 PEM> - TLS certificate in Base64-encoded PEM. Required if --protocol is https
+      \x5--tls_key=<base64 PEM> - TLS key in Base64-encoded PEM. Required if --protocol is https
+      \x5--port=<n> - Port to listen on. Defaults to 80 to match default protocol
+      \x5--max_request_size=<nn> - Maximum request content size, in MB
+      \x5--policy=<least_conn | random | round_robin | ip_hash> - Balancing policy to choose backends
+      \x5--health_check_path=<URL> - Which URL to use to determine if backend status is OK (2xx/3xx status)
+      \x5--fail_timeout=<seconds> - Backend timeout in seconds
+      \x5--max_conns=<connections> - Maximum concurrent connections to each backend
+      \x5--ignore_invalid_backend_tls=<true | false> - Should self-signed/invalid certificates be ignored from the backend servers?
+      \x5--backend=<instance_id:instance_id protocol:http | https port:number> - A backend instance, with the instance ID, desired protocol and port number specified.
+      LONGDESC
+    def update(id, hostname = nil, protocol = nil, tls_certificate = nil, tls_key = nil, port = nil, max_request_size = nil, policy = nil, health_check_path = nil, fail_timeout = nil, max_conns = nil, ignore_invalid_backend_tls = nil, backend = nil)
+      CivoCLI::Config.set_api_auth
+      loadbalancer = Civo::LoadBalancer.all.items.detect {|key| key.id == id}
+      if options[:backend]
+        backends = {}
+        options[:backend].each do | key, value |
+          backends[key] = value
+      end
+      backendarray = []
+      backendarray << backends
+      end
+      Civo::LoadBalancer.update(id: loadbalancer.id, 
+        hostname: options[:hostname] || loadbalancer.hostname, 
+        protocol: options[:protocol] || loadbalancer.protocol, 
+        tls_certificate: options[:tls_certificate] || loadbalancer.tls_certificate,
+        tls_key: options[:tls_key] || loadbalancer.tls_key,
+        port: options[:port] || loadbalancer.port,
+        max_request_size: options[:max_request_size] || loadbalancer.max_request_size,
+        policy: options[:policy] || loadbalancer.policy,
+        health_check_path: options[:health_check_path] || loadbalancer.health_check_path,
+        fail_timeout: options[:fail_timeout] || loadbalancer.fail_timeout,
+        max_conns: options[:max_conns] || loadbalancer.max_conns, 
+        ignore_invalid_backend_tls: options[:ignore_invalid_backend_tls] || loadbalancer.ignore_invalid_backend_tls,
+        backends: backendarray || loadbalancer.backends
+      )
+      puts "Updated Load Balancer #{loadbalancer.hostname.colorize(:green)}"
+    end
+    map "change" => "update"
+
+    desc "remove ID", "remove the load balancer with ID"
+    def remove(id)
+      CivoCLI::Config.set_api_auth
+      loadbalancer = Civo::LoadBalancer.all.items.detect {|key| key.id == id}
+      Civo::LoadBalancer.remove(id: id)
+      puts "Removed the load balancer #{loadbalancer.hostname.colorize(:green)} with ID #{loadbalancer.id.colorize(:green)}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "delete" => "remove", "rm" => "remove"
+
+    default_task :help
+
+  end
+end

data/lib/snapshot.rb

@@ -16,7 +16,6 @@ module CivoCLI
     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)

data/lib/timer.rb

@@ -0,0 +1,16 @@
+module CivoCLI
+  class Timer
+
+    attr_accessor :time_elapsed
+
+    def start_timer
+      @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def end_timer
+      end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      @time_elapsed = (end_time - @start_time).round(2)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: civo_cli
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.3.10
 platform: ruby
 authors:
 - Andy Jeffries
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-12 00:00:00.000000000 Z
+date: 2019-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -214,6 +214,7 @@ files:
 - lib/firewall.rb
 - lib/instance.rb
 - lib/kubernetes.rb
+- lib/loadbalancer.rb
 - lib/namegenerator.rb
 - lib/network.rb
 - lib/quota.rb
@@ -224,6 +225,7 @@ files:
 - lib/sshkey.rb
 - lib/sub_command_base.rb
 - lib/template.rb
+- lib/timer.rb
 - lib/volume.rb
 homepage: https://www.civo.com/api
 licenses: