civo_cli 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 927ddbd3f24ce34b813e67e1b2272aa26246901174c381a2d50c1ecaba04ef2f
-  data.tar.gz: f3fca2349b9447087fe43fcbf560469ebab6c891586cfd1627605233b90a9eab
+  metadata.gz: d11ea9765c6587f9b9fe117fb9c3ff15b50cae5fddd6110191f71c819e235b9e
+  data.tar.gz: cb754f79de7af4b2072c0ecbe51285887d7688f0c569d9057fb466112a3da331
 SHA512:
-  metadata.gz: 32fa783327ab26f639c58cfff0bf6e199b8a955d8b5ba0f6330671ab0ee9bca1739252d1dab609091205695391e068132220a31c8780a273bf5ee217caf5d5e6
-  data.tar.gz: 7118dc6fc3c150b1e5329ca122f1cd4cf2939f73798c7346385c2822e6c2152e65e9d3d3fe8699a302693de76acced627e3b3795ff130f521275c3c1de89bfbc
+  metadata.gz: efcabbc75b6bf60c6750a1b7b0dcc8359211ef6ad69139691f925bcd99fe340150cf05206cb695416a187515855fe94e59b6f904d556aea9e8461524bfab47bf
+  data.tar.gz: cabfc6bfdcf8dd8cbfd7606f42c23cb4881c3960ff7cee8198102e23484acabb7d40d7103940a4fa8a5cbde01c19fbec0008e80ca9e44e4e799cb219daeffe82

data/CHANGELOG.md

@@ -1,2 +1,10 @@
-# Civo CLI Changlog
+# Changelog
+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.12.0] - 2017-06-20
+### Rewrote
+- Written new version in Ruby for ease of maintenance that replaces the old [Go-based CLI](https://github.com/absolutedevops/civo)
+
+[1.0.0]: https://github.com/olivierlacan/keep-a-changelog/compare/v0.3.0...v1.0.0

data/Gemfile.lock

@@ -0,0 +1,128 @@
+PATH
+  remote: .
+  specs:
+    civo_cli (0.1.1)
+      civo (>= 1.1.14)
+      colorize
+      json
+      terminal-table
+      thor
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    addressable (2.6.0)
+      public_suffix (>= 2.0.2, < 4.0)
+    civo (1.1.14)
+      commander
+      flexirest (>= 1.4.6)
+      toml
+    coderay (1.1.2)
+    colorize (0.8.1)
+    commander (4.4.7)
+      highline (~> 2.0.0)
+    concurrent-ruby (1.1.5)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.3)
+    faraday (0.15.4)
+      multipart-post (>= 1.2, < 3)
+    ffi (1.10.0)
+    flexirest (1.7.6)
+      activesupport
+      crack
+      faraday
+      multi_json
+    formatador (0.2.5)
+    guard (2.15.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    hashdiff (0.3.8)
+    highline (2.0.1)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    json (2.2.0)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    lumberjack (1.0.13)
+    method_source (0.9.2)
+    minitest (5.11.3)
+    multi_json (1.13.1)
+    multipart-post (2.0.0)
+    nenv (0.3.0)
+    notiffany (0.1.1)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    parslet (1.8.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    public_suffix (3.0.3)
+    rake (10.5.0)
+    rb-fsevent (0.10.3)
+    rb-inotify (0.10.0)
+      ffi (~> 1.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    ruby_dep (1.5.0)
+    safe_yaml (1.0.5)
+    shellany (0.0.1)
+    terminal-notifier-guard (1.7.0)
+    terminal-table (1.8.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
+    thor (0.20.3)
+    thread_safe (0.3.6)
+    toml (0.2.0)
+      parslet (~> 1.8.0)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.4.1)
+    webmock (3.5.1)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  civo_cli!
+  guard
+  guard-rspec
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  terminal-notifier-guard
+  webmock
+
+BUNDLED WITH
+   1.17.2

data/Guardfile

@@ -0,0 +1,43 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "RUBYOPT=W0 bundle exec rspec", all_on_start: true, title: "Ruby Civo CLI Specs" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+end

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019 Andy Jeffries
+Copyright (c) 2019 Aboslute Devops Ltd
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,28 +1,201 @@
-# CivoCli
+# Civo Command-Line Client
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/civo_cli`. To experiment with that code, run `bin/console` for an interactive prompt.
+This utility is for interacting with the Civo Cloud API provided on Civo.com. In order to use the API you need an API key, which is available when you're logged in to Civo.com at https://www.civo.com/api.
 
-TODO: Delete this and the text above, and describe your gem
+## Installation/overview
 
-## Installation
+The first step should be to download the client. This is simply done using:
 
-Add this line to your application's Gemfile:
+```
+gem install civo_cli
+```
+
+You'll then need to run a command in a Terminal to register your API key with the client. Let's take the example that your company is called "Acme Widgets" and your API key is "123456789012345678901234567890". You need to give the API key a short reference when saving it, such as `acme` (because you can register multiple API keys for different accounts in the same client):
+
+```
+civo apikeys save -n acme -k 123456789012345678901234567890
+```
+
+You will then need to set this as your default apikey to be used in all future requests with:
+
+```
+civo apikeys default -n acme
+```
+
+Now you are free to use the remaining commands in the system. We'll work through the most common ones below, the rest are normally used by Civo administrators (and the permission levels associated with your apikey in CIvo won't allow you to make them).
+
+In order to discover the available commands you can use `civo -h` to list the available commands, then use `civo [command] -h` to list sub commands and so on further down the line.  For example:
+
+```
+civo -h
+civo instances -h
+civo instances create -h
+```
+
+In this way all the possible things you can do with the client are discoverable.
+
+
+## SSH keys
+
+One of the first things you'll likely want to do is upload your SSH public key, so that you can SSH in to new instances - you can't create a new instance without this step.
+
+Assuming your public key is in `~/.ssh/id_rsa.pub` (if it isn't, you'll probably know why and where it is) you can upload this with:
+
+```
+civo sshkey upload --name default --public-key ~/.ssh/id_rsa.pub
+```
+
+If you want to remove a public key (say you are replacing it with a new one), you can do this with:
+
+```
+civo sshkey delete --name default
+```
+
+**Note:** This won't remove it from your currently running instances, it will only affect new instances created.
+
+
+## Choosing the specification of an instance
+When creating an instance, you'll need to specify items such as the size of instance, which region to create it in (if your provider supports multiple regions) and the template to use (from the available operating systems, versions and layered applications).
+
+The information on all of these are available by running `civo size`, `civo region` and `civo template`.  The output of the command will give you the key to use when creating the instance.  For example (and these are subject to change):
+
+```
+$ civo size
++-----------+----------------------------------------------------+
+|   Name    |                   Specification                    |
++-----------+----------------------------------------------------+
+| g1.xsmall | Extra Small - 512MB RAM, 1 CPU Core, 20GB SSD Disk |
+| g1.small  | Small - 1GB RAM, 2 CPU Cores, 50GB SSD Disk        |
+| g1.medium | Medium - 2GB RAM, 4 CPU Cores, 100GB SSD Disk      |
+| g1.large  | Large - 4GB RAM, 6 CPU Cores, 150GB SSD Disk       |
+| g1.xlarge | Extra Large - 8GB RAM, 8 CPU Cores, 200GB SSD Disk |
++-----------+----------------------------------------------------+
+
+$ civo template
++--------------------+------------------------------------------------------------------------+
+|         ID         |                              Description                               |
++--------------------+------------------------------------------------------------------------+
+| centos-7           | CentOS version 7 (RHEL open source clone)                              |
+| ubuntu-14.04-vesta | Canonical's Ubuntu 14.04 with the Vesta Control Panel                  |
+| ubuntu-14.04       | Canonical's Ubuntu 14.04 installed in a minimal configuration          |
++--------------------+------------------------------------------------------------------------+
+```
+
+
+## Managing instances
+
+To view the list of your currently running instances you can simply run:
+
+```
+civo instance
+```
+
+This will output a table listing the instances currently in your account:
+
+```
++----------+-------------------+----------+-------------------------------+--------+------+--------------+
+|    ID    |       Name        |   Size   |         IP Addresses          | Status | User |   Password   |
++----------+-------------------+----------+-------------------------------+--------+------+--------------+
+| 8043d0e7 | test1.example.com | g1.small | 10.0.0.2=>31.28.88.103        | ACTIVE | civo | jioAQfSDffFS |
++----------+-------------------+----------+-------------------------------+--------+------+--------------+
+```
 
-```ruby
-gem 'civo_cli'
+Creating an instance is a simple command away (remember, if you can't remember the parameters `civo instance create -h` is there to help you) using something like:
+
+```
+civo instance create --name test2.example.com --size g1.small \
+  --region svg1 --ssh-key-id default --template ubuntu-14.04 --public-ip
+```
+
+If you don't specify a name, a random one will be created for you.
+
+**Note:** Specifying the name will set the hostname on the machine but won't affect DNS resolution, currently that's up to you to provide separately.
+
+If you decide you don't need an instance any more you can remove it by simply calling `civo instance destroy` passing in either the ID or the name, using the details above as an example:
+
+```
+civo instance destroy -i8043d0e7
+civo instance destroy --id=test1.example.com
+```
+
+**Note:** The machine will be forever destroyed at this point, you can't get the data back from the hard drive afterwards.
+
+If your machine gets stuck you can restart it with (again using either the ID or the name):
+
+```
+civo instance reboot --id=8043d0e7
+```
+
+If it's *really* stuck (i.e. hard kernel lock) then you can do the cloud equivalent of unplugging it and plugging it back in with the addition of the hard switch:
+
+```
+civo instance reboot --hard --id=8043d0e7
+```
+
+## Snapshots (backups)
+
+If you want to take a snapshot of an instance, you can do this using a single command line like this:
+
+```
+civo snapshot create --name my-backup --instance 8043d0e7 --safe
 ```
 
-And then execute:
+The name can be anything you choose, it won't conflict if you create two snapshots with the same name (but it will make it harder for you to remember which is which).  The instance has to be part of the ID or a unique part of the hostname.  The `--safe` is optional - without this switch it will snapshot your instance while it runs, with the flag it will shut the instance down first, take a snapshot then start it back up.  The reason it's referred to as `safe` is that if you snapshot a running instance, any database server may be the middle of rewriting files for example, leaving them in a half-rewritten and hence corrupted state. If you know your machine is in a good state (say it's an application server), then you can snapshot while it's running.
 
-    $ bundle
+## Firewalls
 
-Or install it yourself as:
+By default all ports and protocols are open on your instance.  We would recommend either using something like [iptables](http://netfilter.org/projects/iptables/) or [Ucomplicated Fire Wall](https://help.ubuntu.com/community/UFW) on the instance, or using the Civo firewall functionality which sits outside your instance (and hence can't be turned off if the machine is compromised).
 
-    $ gem install civo_cli
+The first step is to create a new firewall with:
 
-## Usage
+```
+civo firewall create --name my-firewall
+```
+
+For confirmation that this has worked you can run `civo firewall` to list the firewalls. Then you can add rules to it with commands like (to allow incoming SSH and pings):
+
+```
+civo firewall rules create my-firewall -p tcp -s 22
+civo firewall rules create my-firewall -p icmp
+```
+
+You can check that it's configured correctly by running `civo firewall rules my-firewall`. Now that you're sure your firewall is configured, you can assign it to one or more instances with:
+
+```
+civo instances firewall --id=8043d0e7 --firewall my-firewall
+```
+
+If you make a mistake at any point, you can revert to the default firewall by simply running the same command without `--firewall ...`, for example:
 
-TODO: Write usage instructions here
+```
+civo instances firewall --id=8043d0e7
+```
+
+## Quota
+
+All Civo users have a limited quota applied to their account (to stop errant scripts from filling up the cloud with a million instances).  You can view your current quota using a command like this:
+
+```
+$ civo quota
++---------------------------------------+------+-------+
+|                 Title                 | Used | Limit |
++---------------------------------------+------+-------+
+| Number of instances                   |    0 |    10 |
+| Total CPU cores                       |    0 |    20 |
+| Total RAM (MB)                        |    0 |  5120 |
+| Total disk space (GB)                 |    0 |   250 |
+| Disk volumes                          |    0 |    10 |
+| Disk snapshots                        |    0 |    30 |
+| Public IP addresses                   |    0 |    10 |
+| Private subnets                       |    0 |     1 |
+| Private networks                      |    0 |     1 |
+| Security groups                       |    0 |    10 |
+| Security group rules                  |    0 |   100 |
+| Number of ports (network connections) |    0 |    20 |
++---------------------------------------+------+-------+
+```
+
+If you want to increase them, contact us via Civo.com.
 
 ## Development
 
@@ -30,10 +203,18 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+For more information on some commonly used Gems in this project see:
+
+* [Civo API](https://github.com/absolutedevops/civo-ruby)
+* [Thor](http://whatisthor.com/)
+* [Terminal Table](https://github.com/tj/terminal-table)
+* [Colorize](https://github.com/fazibear/colorize)
+
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/andyjeffries/civo_cli.
+Bug reports and pull requests are welcome on GitHub at https://github.com/civo/cli.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

data/civo_cli.gemspec

@@ -5,9 +5,9 @@ require "civo_cli/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "civo_cli"
-  spec.version       = CivoCli::VERSION
-  spec.authors       = ["Andy Jeffries"]
-  spec.email         = ["andy@absolutedevops.io"]
+  spec.version       = CivoCLI::VERSION
+  spec.authors       = ["Andy Jeffries", "Absolute Devops Ltd"]
+  spec.email         = ["andy@absolutedevops.io", "hello@civo.com"]
 
   spec.summary       = %q{CLI for interacting with Civo.com}
   spec.description   = %q{The official command line client for interacting with Civo's API}
@@ -36,7 +36,19 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '~> 2.0'
+
   spec.add_development_dependency "bundler", "~> 1.17"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency 'terminal-notifier-guard'
+  spec.add_development_dependency 'webmock'
+
+  spec.add_runtime_dependency 'terminal-table'
+  spec.add_runtime_dependency 'thor'
+  spec.add_runtime_dependency 'colorize'
+  spec.add_runtime_dependency 'civo', ">= 1.1.14"
+  spec.add_runtime_dependency 'json'
 end

data/exe/civo

@@ -3,3 +3,4 @@
 require "bundler/setup"
 require "civo_cli"
 
+CivoCLI::Main.start(ARGV) if __FILE__ == $0

data/lib/apikey.rb

@@ -0,0 +1,50 @@
+module CivoCLI
+  class APIKey < Thor
+    desc "list", "List all stored API keys"
+    def list
+      keys = CivoCLI::Config.get_apikeys
+      default = CivoCLI::Config.get_meta(:current_apikey)
+
+      rows = []
+      keys.each do |label, key|
+        if label == default
+          rows << [label, key, "<====="]
+        else
+          rows << [label, key, ""]
+        end
+      end
+      puts Terminal::Table.new headings: ['Name', 'Key', 'Default?'], rows: rows
+    end
+
+    desc "add NAME KEY", "Add the API Key 'KEY' using a label of 'NAME'"
+    def add(name, key)
+      CivoCLI::Config.set_apikey(name, key)
+      puts "Saved the API Key #{key.colorize(:green)} as #{name.colorize(:green)}"
+    end
+
+    desc "remove NAME", "Remove the API Key with a label of 'NAME'"
+    def remove(name)
+      CivoCLI::Config.delete_apikey(name)
+      puts "Removed the API Key #{name.colorize(:green)}"
+    end
+    map "delete" => "remove", "rm" => "remove"
+
+    desc "current [NAME]", "Either return the name of the current API key or set the current key to be the one with a label of 'NAME'"
+    def current(name=nil)
+      if name.nil?
+        puts "The current API Key is #{CivoCLI::Config.get_current_apikey_name.colorize(:green)}"
+      else
+        keys = CivoCLI::Config.get_apikeys
+        if keys.keys.include?(name)
+          CivoCLI::Config.set_meta(:current_apikey, name)
+          puts "The current API Key is now #{CivoCLI::Config.get_current_apikey_name.colorize(:green)}"
+        else
+          puts "The API Key #{name.colorize(:red)} couldn't be found, so it could not be set as default"
+          exit 1
+        end
+      end
+    end
+
+    default_task :list
+  end
+end

data/lib/blueprint.rb

@@ -0,0 +1,83 @@
+module CivoCLI
+  class Blueprint < Thor
+    desc "list", "list all blueprints"
+    def list
+      CivoCLI::Config.set_api_auth
+      rows = []
+      Civo::Blueprint.all.items.each do |blueprint|
+        rows << [blueprint.id, blueprint.name, blueprint.template_id, blueprint.version, blueprint.last_build_ended_at]
+      end
+      puts Terminal::Table.new headings: ['ID', 'Name', 'Template ID', 'Version', "Last built"], rows: rows
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+
+    desc "show ID", "show the details for a single blueprint"
+    def show(id)
+      CivoCLI::Config.set_api_auth
+      blueprint = Civo::Blueprint.all.detect {|b| b.id == id }
+      puts "                ID : #{blueprint.id}"
+      puts "              Name : #{blueprint.name}"
+      puts "       Template ID : #{blueprint.template_id}"
+      puts "           Version : #{blueprint.version}"
+      puts "Last Build Started : #{blueprint.last_build_started_at&.strftime("%-d %B %Y, %H:%M:%S")}"
+      puts "  Last Build Ended : #{blueprint.last_build_ended_at&.strftime("%-d %B %Y, %H:%M:%S")}"
+      puts ""
+      puts "-" * 29 + " CONTENT " + "-" * 29
+      puts ""
+      puts blueprint.dsl_content
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+
+    option "content-file", type: :string, desc: "The filename of a file to be used as the Blueprintfile content", aliases: ["-c"], banner: "CONTENT_FILE"
+    option "template-id", type: :string, desc: "The ID of the template to update", aliases: ["-t"], banner: "TEMPLATE_ID"
+    option :name, type: :string, desc: "A nice name to be used for the blueprint", aliases: ["-n"], banner: "NICE_NAME"
+    desc "update ID", "update the blueprint with ID"
+    def update(id)
+      CivoCLI::Config.set_api_auth
+      params = {id: id}
+      params[:dsl_content] = File.read(options["content-file"]) unless options["content-file"].nil?
+      params[:template_id] = options["template-id"] unless options["template-id"].nil?
+      params[:name] = options["name"] unless options["name"].nil?
+      Civo::Blueprint.save(params)
+      blueprint = Civo::Blueprint.all.detect {|b| b.id == id }
+      puts "Updated blueprint #{blueprint.name.colorize(:green)}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+
+    option "content-file", type: :string, desc: "The filename of a file to be used as the Blueprintfile content", aliases: ["-c"], banner: "CONTENT_FILE"
+    option "template-id", type: :string, desc: "The ID of the template to update", aliases: ["-t"], banner: "TEMPLATE_ID"
+    option :name, type: :string, desc: "A nice name to be used for the blueprint", aliases: ["-n"], banner: "NICE_NAME"
+    desc "create", "create a new blueprint"
+    def create
+      CivoCLI::Config.set_api_auth
+      params = {}
+      params[:dsl_content] = File.read(options["content-file"]) unless options["content-file"].nil?
+      params[:template_id] = options["template-id"] unless options["template-id"].nil?
+      params[:name] = options["name"] unless options["name"].nil?
+      blueprint = Civo::Blueprint.create(params)
+      puts "Created blueprint #{blueprint.name.colorize(:green)} with ID #{blueprint.id.colorize(:green)}"
+    rescue Flexirest::HTTPException => e
+      puts e.result.reason.colorize(:red)
+      exit 1
+    end
+    map "new" => "create"
+
+    desc "remove ID", "remove the blueprint with ID"
+    def remove(id)
+      CivoCLI::Config.set_api_auth
+      Civo::Blueprint.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

data/lib/civo_cli/version.rb

@@ -1,3 +1,3 @@
-module CivoCli
-  VERSION = "0.1.0"
+module CivoCLI
+  VERSION = "0.1.1"
 end