wavefront-cli 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd9a4217e92b817721a7437e19ec3733bd06cd3c
+  data.tar.gz: '019e98583f888391f948e7f82266ff2cdb902a3b'
+SHA512:
+  metadata.gz: fb04299e0ad36f4f4cc6c587483574859a93794a317e9c54a127b1821894dad3d25a34eade8ad81ce290aedc8b8df24d44b9853d062433d8e3a6c7d1343bb8f4
+  data.tar.gz: 926c982c2fccb55b043c8780662ab37e4f12481c91f24a3fc51d81c8e9a0226a4172522d46bef8db1d18769a7b5fb521c3d1332a22ce0f868a887c87bd5d2386

data/.codeclimate.yml

@@ -0,0 +1,20 @@
+---
+engines:
+  duplication:
+    enabled: true
+    checks:
+      Similar code:
+        enabled: false
+    config:
+      languages:
+      - ruby
+  fixme:
+    enabled: true
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - "**.rb"
+exclude_paths:
+  - spec/
+  - lib/_wavefront

data/.gitignore

@@ -0,0 +1,4 @@
+.yardoc
+/doc
+.*swp
+*.gem

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+cache: bundler
+rvm:
+- 2.2.7
+- 2.3.4
+- 2.4.1
+before_install: gem install bundler --no-rdoc --no-ri
+deploy:
+  provider: rubygems
+  api_key:
+    secure: dfmL5JwBn+u3cUmyAaDsApDa7ljGajGNz3GDcKd2J8FOt7+a758/lmL8EQ34sDT1ZFotrxn/y1RbgXlaDxAE1XDfrZbjckmx7a6wa2sqR3kBraJ2tx7CiXodbw3Z8XZf9WLb0kYGmlLtI73GNcuunMt/9f1cobqWISRLHw6b7amlO7GW2ZBZgzRS+N8TSS2dicIvKMo5HoMYU+uWLM4zDFBPnGNcMiWxh8ysLzJoKqA9kbBUyCVEZ03MlV7G71ObvWCLasKnZ3W5U+K1NbgU7mgMYfl9KIcA4y9hQ9hUCijk40SmT7ffy3P2gq8zblC/4x5Eefpau9X/bdLwXoRCIzqk05t4f45wstj2auHGK0HJwOYRtx8apdaLSgyJ5lQpGcbCRu40WR9mDkaM8m9n3u2o6GJmftCg3AN1QtsourmQB84x67LEbHzValMaokrbCol4XeWqlC+dCNLPixemQRBvcNfI3V9C6RqVGfjpoGlSTI+RkQqwm01PcxpeqIVfdMd1wnfUuAOywUO6UpvtK9TZaxg0NnVElXpPseQbtzulLwZ7R5Y3A4Ss8Z7w43c1KHxTkg54FWUOp065ItjAc4lmyORXq/2+F7sMvRN6dtCLaXTUlkYuU3cjFLIPlLGFYgqq4T4xQa+e5NEK1XW7nghv+IRfKfyVeZsB0WpY+uc=
+  gem: wavefront-cli
+  on:
+    tags: true
+    repo: snltd/wavefront-cli
+    ruby: 2.3.4

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'                                                                                                  
+gemspec

data/Gemfile.lock

@@ -0,0 +1,65 @@
+PATH
+  remote: .
+  specs:
+    wavefront-cli (0.0.2)
+      docopt (= 0.5.0)
+      wavefront-sdk (~> 0.1.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.5.1)
+      public_suffix (~> 2.0, >= 2.0.2)
+    ast (2.3.0)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    docopt (0.5.0)
+    faraday (0.12.1)
+      multipart-post (>= 1.2, < 3)
+    hashdiff (0.3.2)
+    inifile (3.0.0)
+    map (6.6.0)
+    minitest (5.8.5)
+    multipart-post (2.0.0)
+    parser (2.4.0.0)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    public_suffix (2.0.5)
+    rainbow (2.2.1)
+    rake (12.0.0)
+    rubocop (0.47.1)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    safe_yaml (1.0.4)
+    spy (0.4.5)
+    unicode-display_width (1.1.3)
+    wavefront-sdk (0.1.5)
+      addressable (~> 2.4)
+      faraday (>= 0.12.1, < 0.13)
+      inifile (>= 3.0.0)
+      map (~> 6.6.0)
+    webmock (2.3.2)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+    yard (0.9.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  minitest (~> 5.8, >= 5.8.0)
+  rake (~> 12.0)
+  rubocop (~> 0.47.0)
+  spy (~> 0.4.0)
+  wavefront-cli!
+  webmock (~> 2.3, >= 2.3.2)
+  yard (~> 0.9.5)
+
+BUNDLED WITH
+   1.14.6

data/README.md

@@ -0,0 +1,221 @@
+# Wavefront CLI [![Build Status](https://travis-ci.org/snltd/wavefront-cli.svg?branch=master)](https://travis-ci.org/snltd/wavefront-cli) [![Code Climate](https://codeclimate.com/github/snltd/wavefront-cli/badges/gpa.svg)](https://codeclimate.com/github/snltd/wavefront-cli) [![Issue Count](https://codeclimate.com/github/snltd/wavefront-cli/badges/issue_count.svg)](https://codeclimate.com/github/snltd/wavefront-cli) [![Known Vulnerabilities](https://snyk.io/test/github/snltd/wavefront-cli/badge.svg)](https://snyk.io/test/github/snltd/wavefront-cli)
+
+
+This package provides a command-line interface to Wavefront's API. Each API path
+is covered by a different command keyword.
+
+It is built on [the Wavefront Ruby
+SDK](https://github.com/snltd/wavefront-sdk) and requires Ruby >= 2.2.
+
+```
+$ wavefront --help
+Wavefront CLI
+
+Usage:
+  wavefront [options] command [options]
+  wavefront --version
+  wavefront --help
+
+Commands:
+  alert         view and manage alerts
+  integration   view and manage cloud integrations
+  dashboard     view and manage dashboards
+  event         view, manage, open, and close events
+  link          view and manage external links
+  message       view and mark as read user messages
+  metric        view metric details
+  proxy         view and manage Wavefront proxies
+  query         run timeseries queries
+  savedsearch   view and manage saved searches
+  source        view and manage source tags and descriptions
+  user          view and manage Wavefront users
+  window        view and manage maintenance windows
+  webhook       view and manage webhooks
+  write         send data points to a Wavefront proxy
+
+Use 'wavefront <command> --help' for further information.
+```
+
+## General Rules
+
+### Credentials and the Config File
+
+You can pass in your Wavefront API and token with command-line
+options `-E` and `-t`; with the environment variables
+`WAVEFRONT_ENDPOINT` and `WAVEFRONT_TOKEN`,
+or by putting them in a configuration file at `${HOME}/.wavefront`. This is an
+ini-style file, with a section for each Wavefront account you wish to use. (None
+of the tokens shown here are real, of course!)
+
+```
+[default]
+token = 106ba476-e3bd-c14c-4a3d-391cd4c11def
+endpoint = metrics.wavefront.com
+proxy = wavefront.localnet
+format = human
+
+[company]
+token = 9ac40b15-f47f-a168-a5d3-271ab5bad617
+endpoint = company.wavefront.com
+format = yaml
+```
+
+You can override the config file location with `-c`, and select a profile with
+`-P`. If you don't supply `-P`, the `default` profile is used.
+
+### Listing Things
+
+Most commands have a `list` subcommand, which will produce brief
+"one thing per line" output. The unique ID  of the "thing" is in the first
+column.
+
+```
+$ wavefront proxy list
+457d6cf3-5171-45e0-8d31-5c980be889ea  test agent
+917102d1-a10e-997b-ba63-95058f98d4fb  Agent on wavefront-2017-03-13-02
+926dfb4c-23c6-4fb9-8c8d-833625ab8f6f  Agent on shark-wavefront
+```
+
+You can get more verbose listings with the `-l` flag.
+
+### Describing Things
+
+Most commands have a `describe` subcommand which will tell you more about the
+object.
+
+```
+$ wavefront proxy describe 917102d1-a10e-497b-ba63-95058f98d4fb
+name                     Agent on wavefront-2017-03-13-02
+id                       917102d1-a10e-497b-ba63-95058f98d4fb
+version                  4.7
+customerId               sysdef
+inTrash                  false
+lastCheckInTime          2017-06-06 14:47:20
+hostname                 wavefront-2017-03-13-02
+timeDrift                -751
+bytesLeftForBuffer       1536094720
+bytesPerMinuteForBuffer  280109
+localQueueSize           0
+sshAgent                 false
+ephemeral                false
+deleted                  false
+```
+
+Most timestamps come back from the API as epoch seconds or epoch milliseconds.
+The CLI, in its human-readable descriptions, will convert those to
+`YYYY-MM-DD HH:mm:ss` when it `describe`s something.
+
+### Formats, Importing, and Exporting
+
+Most commands and sub-commands support the `-f` option. This takes one of
+`json`, `yaml`, `human` and `raw`, and tells the CLI to present the information
+it fetches from the Wavefront API in that format. (`raw` is the raw Ruby
+representation, which, for instance, you could paste into `irb`.)
+
+Human output can be selective. As well as the time formatting mentioned above,
+human-readable listings and desctiptions may omit data which is not likely to be
+useful, or which is extremely hard to present in a readable way.
+
+If you `describe` an object like a dashboard, user, webhook etc as `json` or
+`yaml`, and send the output to a file, you can re-import that data. The format of the file to be imported is automatically detected.
+
+```
+$ wavefront user list
+slackboy@gmail.com
+sysdef.limited@gmail.com
+$ wavefront user describe -f json sysdef.limited@gmail.com > user.json
+$ cat user.json
+{"identifier":"sysdef.limited@gmail.com","customer":"sysdef","groups":["agent_management"]}
+$ wavefront user delete sysdef.limited@gmail.com
+Deleted user 'sysdef.limited@gmail.com'.
+$ wavefront user list
+slackboy@gmail.com
+$ wavefront user import user.json
+Imported user.
+identifier  sysdef.limited@gmail.com
+customer    sysdef
+groups      agent_management
+$ wavefront user list
+slackboy@gmail.com
+sysdef.limited@gmail.com
+```
+
+You could, of course, modify certain aspects of the exported data before
+re-importing.
+
+### Time Windows
+
+Commands which operate on a time window, such as `query` or `event`
+will expect that window to be defined with `-s` and `-e` (or
+`--start` and `--end`). Times can be in seconds since the epoch, or
+any format which [Ruby's `strptime`
+method](https://ruby-doc.org/stdlib-2.3.1/libdoc/date/rdoc/DateTime.html#method-c-strptime)
+method can parse unaided. For instance:
+
+```
+$ wavefront --start 12:15 --end 12:20 ...
+```
+
+will define a window between 12:15 and 12:20pm today. If you ran
+that in the morning, the time would be invalid, and you would get a
+400 error from Wavefront, so something of the form
+`2016-04-17T12:25:00` would remove all ambiguity.
+
+There is no need to include a timezone in your time: the `wavefront`
+CLI will automatically use your local timezone when it parses the
+string.
+
+The following options are valid in almost all contexts.
+
+```
+-c, --config=FILE    path to configuration file [default: ~/.wavefront]
+-P, --profile=NAME   profile in configuration file [default: default]
+-D, --debug          enable debug mode
+-V, --verbose        enable verbose mode
+-h, --help           show help for command
+```
+
+Debug mode will show you combined options, and debug output from
+`faraday`. It also shows the full stack trace should a command
+fail. This output can be very verbose.
+
+## Writing Points
+
+Writing a single point is simple:
+
+```
+$ wavefront write point cli.example 10
+```
+
+and you can add point tags, if you like.
+
+```
+$ wavefront write point cli.example 9.4 -E wavefront -T proxy=wavefront \
+  -T from=README
+```
+
+or force a timestamp:
+
+```
+$ wavefront write point -t 16:53:14 cli.example 8
+```
+
+More usefully, you can write from a file. Your file must contain multiple
+columns: metric name (`m`), metric value (`v`), timestamp(`t`), and point tags
+(`T`). `v` is mandatory, `m` can be filled in with the `-m` flag, `t` can be
+filled in with the current timestamp, and `T` is optional, but if used, must be
+last. You then tell the CLI what order your fields are in.
+
+```
+$ cat datafile
+1496767813 dev.cli.test 12.1
+1496767813 dev.cli.test 10.0
+1496767813 dev.cli.test 14.5
+$ wavefront write file -F tmv datafile
+```
+
+If you set the file to `-`, you can read from standard in:
+
+```
+$ while true; do echo $RANDOM; sleep 1; done | wavefront write file -m cli.demo -Fv -
+```

data/Rakefile

@@ -0,0 +1,18 @@
+require 'yard'
+require 'rake/testtask'
+require 'rubocop/rake_task'
+
+task default: :test
+
+Rake::TestTask.new do |t|
+  t.pattern = 'spec/wavefront-cli/*_spec.rb'
+  t.warning = false
+end
+
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.options = ['--display-cop-names']
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/wavefront-cli/*rb']
+end

data/bin/wavefront

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require 'io/console'
+require_relative '../lib/wavefront-cli/controller'
+
+begin
+  TW = IO.console.winsize.last
+rescue
+  TW = 80
+end
+
+CMD = Pathname.new(__FILE__).basename
+WavefrontCliController.new(ARGV)

data/lib/wavefront-cli/alert.rb

@@ -0,0 +1,60 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'alert' API.
+  #
+  class Alert < WavefrontCli::Base
+    def do_describe
+      wf.describe(options[:'<id>'], options[:version])
+    end
+
+    def do_snooze
+      wf.snooze(options[:'<id>'], options[:time])
+    end
+
+    def do_unsnooze
+      wf.unsnooze(options[:'<id>'])
+    end
+
+    def do_delete
+      print (if wf.describe(options[:'<id>']).status.code == 200
+              'Soft'
+            else
+              'Permanently'
+            end)
+
+      puts " deleting alert '#{options[:'<id>']}'."
+      wf.delete(options[:'<id>'])
+    end
+
+    def do_summary
+      wf.summary
+    end
+
+    def do_history
+      wf.history(options[:'<id>'], options[:offset], options[:limit])
+    end
+
+    # Take a previously exported alert, and construct a hash which
+    # create() can use to re-create it.
+    #
+    # @param raw [Hash] Ruby hash of imported data
+    #
+    def import_to_create(raw)
+      ret = %w(name condition minutes target severity displayExpression
+               additionalInformation).each_with_object({}) do |k, aggr|
+        aggr[k.to_sym] = raw[k]
+      end
+
+      if raw.key?('resolveAfterMinutes')
+        ret[:resolveMinutes] = raw['resolveAfterMinutes']
+      end
+
+      if raw.key?('customerTagsWithCounts')
+        ret[:sharedTags] = raw['customerTagsWithCounts'].keys
+      end
+      ret
+    end
+  end
+end

data/lib/wavefront-cli/base.rb

@@ -0,0 +1,320 @@
+
+require 'yaml'
+require 'json'
+require 'wavefront-sdk/validators'
+# require_relative './constants'
+require_relative './exception'
+
+module WavefrontCli
+  #
+  # Parent of all the CLI classes. This class uses metaprogramming
+  # techniques to try to make adding new CLI commands and
+  # sub-commands as simple as possible.
+  #
+  # To define a subcommand 'cmd', you only need add it to the
+  # `docopt` description in the relevant section, and create a
+  # method 'do_cmd'.  The WavefrontCli::Base::dispatch() method will
+  # find it, and call it. If your subcommand has multiple words,
+  # like 'delete tag', your do method would be called
+  # `do_delete_tag`. The `do_` methods are able to access the
+  # Wavefront SDK object as `wf`, and all docopt options as
+  # `options`.
+  #
+  class Base
+    attr_accessor :wf, :options, :klass, :klass_word
+
+    include Wavefront::Validators
+
+    def initialize(options)
+      @options = options
+      sdk_class = self.class.name.sub(/Cli/, '')
+      @klass_word = sdk_class.split('::').last.downcase
+      validate_input
+
+      if options.include?(:help) && options[:help]
+        puts options
+        exit 0
+      end
+
+      require File.join('wavefront-sdk', @klass_word)
+      @klass = Object.const_get(sdk_class)
+
+      send(:post_initialize, options) if respond_to?(:post_initialize)
+    end
+
+    def run
+      @wf = klass.new(mk_creds, mk_opts)
+      dispatch
+    end
+
+    # We normally validate with a predictable method name. Alert IDs are
+    # validated with #wf_alert_id? etc. If you need to change that, override
+    # this method.
+    #
+    def validator_method
+      "wf_#{klass_word}_id?".to_sym
+    end
+
+    def validator_exception
+      Object.const_get(
+        "Wavefront::Exception::Invalid#{klass_word.capitalize}Id"
+      )
+    end
+
+    def validate_input
+      validate_id if options[:'<id>']
+      validate_tags if options[:'<tag>']
+      send(:extra_validation) if respond_to?(:extra_validation)
+    end
+
+    def validate_tags
+      Array(options[:'<tag>']).each do |t|
+        begin
+          send(:wf_tag?, t)
+        rescue Wavefront::Exception::InvalidTag
+          abort "'#{t}' is not a valid tag."
+        end
+      end
+    end
+
+    def validate_id
+      send(validator_method, options[:'<id>'])
+    rescue validator_exception
+      abort "'#{options[:'<id>']}' is not a valid #{klass_word} ID."
+    end
+
+    # Make a wavefront-sdk credentials object from standard
+    # options.
+    #
+    # @return [Hash] containing `token` and `endpoint`.
+    #
+    def mk_creds
+      { token: options[:token], endpoint: options[:endpoint] }
+    end
+
+    # Make a common wavefront-sdk options object from standard CLI
+    # options.
+    #
+    # @return [Hash] containing `debug`, `verbose`, and `noop`.
+    #
+    def mk_opts
+      { debug: options[:debug], verbose: options[:verbose],
+        noop: options[:noop] }
+    end
+
+    # To allow a user to default to different output formats for
+    # different object, we define a format for each class. For
+    # instance, `alertformat` or `agentformat`. This method returns
+    # such a string appropriate for the inheriting class.
+    #
+    # @return [Symbol] name of the option or config-file key which
+    #   sets the default output format for this class
+    #
+    def format_var
+      options[:format].to_sym
+      # (self.class.name.split('::').last.downcase + 'format').to_sym
+    end
+
+    # Works out the user's command by matching any options docopt has
+    # set to 'true' with any 'do_' method in the class. Then calls that
+    # method, and displays whatever it returns.
+    #
+    # @return [nil]
+    # @raise 'unsupported command', if the command does not match a
+    #   `do_` method.
+    #
+    def dispatch
+      #
+      # Take a list of do_ methods, remove the 'do_' from their name,
+      # and break them into arrays of '_' separated words.
+      #
+      m_list = methods.select { |m| m.to_s.start_with?('do_') }.map do |m|
+        m.to_s.split('_')[1..-1]
+      end
+
+      # Sort that array of arrays by length, longest first.  Then look
+      # through each deconstructed method name and see if the user
+      # supplied an option for each component. Call the first one that
+      # matches. The order will ensure we match "do_delete_tags" before
+      # we match "do_delete".
+      #
+      m_list.sort_by(&:length).reverse.each do |m|
+        if m.reject { |w| options[w.to_sym] }.empty?
+          method = (%w(do) + m).join('_')
+          return display(public_send(method), method)
+        end
+      end
+
+      if respond_to?(:do_default)
+        return display(public_send(:do_default), :do_default)
+      end
+
+      raise WavefrontCli::Exception::UnhandledCommand
+    end
+
+    # Display a Ruby object as JSON, YAML, or human-readable.  We
+    # provide a default method to format human-readable output, but
+    # you can override it by creating your own
+    # `humanize_command_output` method
+    # control how its output is handled by setting the `response`
+    # instance variable.
+    #
+    # @param data [WavefrontResponse] an object returned by a
+    #   Wavefront SDK method. This will contain a 'response'
+    #   and 'status' structures.
+    # @param method [String] the name of the method which produced
+    #   this output. Used to find a suitable humanize method.
+    #
+    def display(data, method)
+      [:status, :response].each do |b|
+        abort "no #{b} block in API response" unless data.respond_to?(b)
+      end
+
+      unless check_status(data.status)
+        handle_error(method, data.status.code) if format_var == :human
+        abort "API #{data.status.code}: #{data.status.message}."
+      end
+
+      resp = if data.response.respond_to?(:items)
+               data.response.items
+             else
+               data.response
+             end
+
+      handle_response(resp, format_var, method)
+    end
+
+    def check_status(status)
+      status.respond_to?(:result) && status.result == 'OK'
+    end
+
+    # This gives us a chance to catch different errors in
+    # WavefrontDisplay classes. If nothing catches, them abort.
+    #
+    def handle_error(method, code)
+      k = load_display_class
+      k.new({}, options).run_error([method, code].join('_'))
+    end
+
+    def handle_response(resp, format, method)
+      case format
+      when :json
+        puts resp.to_json
+      when :yaml # We don't want the YAML keys to be symbols.
+        puts JSON.parse(resp.to_json).to_yaml
+      when :ruby
+        p resp
+      when :human
+        k = load_display_class
+        k.new(resp, options).run(method)
+      else
+        raise "Unknown output format '#{format}'."
+      end
+    end
+
+    def load_display_class
+      require_relative File.join('display', klass_word)
+      Object.const_get(klass.name.sub('Wavefront', 'WavefrontDisplay'))
+    end
+
+    # There are things we need to have. If we don't have them, stop
+    # the user right now. Also, if we're in debug mode, print out a
+    # hash of options, which can be very useful when doing actual
+    # debugging. Some classes may have to override this method. The
+    # writer, for instance, uses a proxy and has no token.
+    #
+    def validate_opts
+      raise 'Please supply an API token.' unless options[:token]
+      raise 'Please supply an API endpoint.' unless options[:endpoint]
+    end
+
+    # Give it a path to a file (as a string) and it will return the
+    # contents of that file as a Ruby object. Automatically detects
+    # JSON and YAML. Raises an exception if it doesn't look like
+    # either.
+    #
+    # @param path [String] the file to load
+    # @return [Hash] a Ruby object of the loaded file
+    # @raise 'Unsupported file format.' if the filetype is unknown.
+    # @raise pass through any error loading or parsing the file
+    #
+    def load_file(path)
+      file = Pathname.new(path)
+      raise 'Import file does not exist.' unless file.exist?
+
+      if file.extname == '.json'
+        JSON.parse(IO.read(file))
+      elsif file.extname == '.yaml' || file.extname == '.yml'
+        YAML.safe_load(IO.read(file))
+      else
+        raise 'Unsupported file format.'
+      end
+    end
+
+    # Below here are common methods. Most are used by most classes,
+    # but if they don't match a command described in the docopt
+    # text, the dispatcher will never call them. So, there's no
+    # harm inheriting unneeded things. Some classes override them.
+    #
+    def do_list
+      wf.list(options[:offset] || 0, options[:limit] || 100)
+    end
+
+    def do_describe
+      wf.describe(options[:'<id>'])
+    end
+
+    def do_import
+      raw = load_file(options[:'<file>'])
+
+      begin
+        prepped = import_to_create(raw)
+      rescue => e
+        puts e if options[:debug]
+        raise 'could not parse input.'
+      end
+
+      wf.create(prepped)
+    end
+
+    def do_delete
+      wf.delete(options[:'<id>'])
+    end
+
+    def do_undelete
+      wf.undelete(options[:'<id>'])
+    end
+
+    def do_update
+      k, v = options[:'<key=value>'].split('=')
+      wf.update(options[:'<id>'], k => v)
+    end
+
+    def do_tags
+      wf.tags(options[:'<id>'])
+    end
+
+    def do_tag_add
+      wf.tag_add(options[:'<id>'], options[:'<tag>'].first)
+    end
+
+    def do_tag_delete
+      wf.tag_delete(options[:'<id>'], options[:'<tag>'].first)
+    end
+
+    def do_tag_set
+      wf.tag_set(options[:'<id>'], options[:'<tag>'])
+    end
+
+    def do_tag_clear
+      wf.tag_set(options[:'<id>'], [])
+    end
+
+    # Most things will re-import with the POST method if you remove
+    # the ID.
+    #
+    def import_to_create(raw)
+      raw.delete_if { |k, _v| k == 'id' }
+    end
+  end
+end