lita-digitalocean 0.0.1 → 1.0.0

data/lib/lita/handlers/digitalocean/domain.rb

@@ -0,0 +1,61 @@
+module Lita
+  module Handlers
+    class Digitalocean < Handler
+      class Domain < Base
+        do_route /^do\s+domains?\s+create\s+[^\s]+\s+[^\s]+$/i, :create, {
+          t("help.domains.create_key") => t("help.domains.create_value")
+        }
+
+        do_route /^do\s+domains?\s+delete\s+[^\s]+$/i, :delete, {
+          t("help.domains.delete_key") => t("help.domains.delete_value")
+        }
+
+        do_route /^do\s+domains?\s+list$/i, :list, {
+          t("help.domains.list_key") => t("help.domains.list_value")
+        }
+
+        do_route /^do\s+domains?\s+show\s+[^\s]+$/i, :show, {
+          t("help.domains.show_key") => t("help.domains.show_value")
+        }
+
+        def create(response)
+          name, ip_address = response.args[2..3]
+
+          do_response = do_call(response) do |client|
+            client.domains.create(name: name, ip_address: ip_address)
+          end or return
+
+          response.reply(t("domains.create.created", do_response[:domain]))
+        end
+
+        def delete(response)
+          do_response = do_call(response) do |client|
+            client.domains.delete(response.args[2])
+          end or return
+
+          response.reply(t("domains.delete.deleted"))
+        end
+
+        def list(response)
+          do_response = do_call(response) do |client|
+            client.domains.list
+          end or return
+
+          messages = do_response[:domains].map { |domain| t("domains.list.detail", domain) }
+
+          response.reply(*messages)
+        end
+
+        def show(response)
+          do_response = do_call(response) do |client|
+            client.domains.show(response.args[2])
+          end or return
+
+          response.reply(t("domains.show.details", do_response[:domain]))
+        end
+      end
+
+      Lita.register_handler(Domain)
+    end
+  end
+end

data/lib/lita/handlers/digitalocean/domain_record.rb

@@ -0,0 +1,99 @@
+module Lita
+  module Handlers
+    class Digitalocean < Handler
+      class DomainRecord < Base
+        do_route /^do\s+domain\s+records?\s+create\s(?:[^\s]+\s+){2}[^\s]/i, :create, {
+          t("help.domain_records.create_key") => t("help.domain_records.create_value")
+        }, {
+          name: {},
+          priority: {},
+          port: {},
+          weight: {}
+        }
+
+        do_route /^do\s+domain\s+records?\s+delete\s+[^\s]+\s+\d+$/i, :delete, {
+          t("help.domain_records.delete_key") => t("help.domain_records.delete_value")
+        }
+
+        do_route /^do\s+domain\s+records?\s+edit\s+(?:[^\s]+\s+){3}[^\s]+/i, :edit, {
+          t("help.domain_records.edit_key") => t("help.domain_records.edit_value")
+        }, {
+          name: {},
+          priority: {},
+          port: {},
+          weight: {}
+        }
+
+        do_route /^do\s+domain\s+records?\s+list\s+[^\s]+$/i, :list, {
+          t("help.domain_records.list_key") => t("help.domain_records.list_value")
+        }
+
+        do_route /^do\s+domain\s+records?\s+show\s+[^\s]+\s+\d+$/i, :show, {
+          t("help.domain_records.show_key") => t("help.domain_records.show_value")
+        }
+
+        def create(response)
+          id, type, data = response.args[3..5]
+
+          params = {
+            data: data,
+            record_type: type
+          }.merge(response.extensions[:kwargs])
+
+          do_response = do_call(response) do |client|
+            client.domains.create_record(id, params)
+          end or return
+
+          response.reply(t("domain_records.create.created", do_response[:record]))
+        end
+
+        def delete(response)
+          id, record_id = response.args[3..4]
+
+          do_response = do_call(response) do |client|
+            client.domains.delete_record(id, record_id)
+          end or return
+
+          response.reply(t("domain_records.delete.deleted"))
+        end
+
+        def edit(response)
+          id, record_id, type, data = response.args[3..6]
+
+          params = {
+            data: data,
+            record_type: type
+          }.merge(response.extensions[:kwargs].reject { |_key, value| value.nil? })
+
+          do_response = do_call(response) do |client|
+            client.domains.edit_record(id, record_id, params)
+          end or return
+
+          response.reply(t("domain_records.edit.updated"))
+        end
+
+        def list(response)
+          do_response = do_call(response) do |client|
+            client.domains.list_records(response.args[3])
+          end or return
+
+          messages = do_response[:records].map { |record| t("domain_records.list.detail", record) }
+
+          response.reply(*messages)
+        end
+
+        def show(response)
+          id, record_id = response.args[3..4]
+
+          do_response = do_call(response) do |client|
+            client.domains.show_record(id, record_id)
+          end or return
+
+          response.reply(t("domain_records.show.details", do_response[:record]))
+        end
+      end
+
+      Lita.register_handler(DomainRecord)
+    end
+  end
+end

data/lib/lita/handlers/digitalocean/droplet.rb

@@ -0,0 +1,236 @@
+module Lita
+  module Handlers
+    class Digitalocean < Handler
+      class Droplet < Base
+        do_route /^do\s+droplets?\s+create(?:\s+[^\s]+){4}/i, :create, {
+          t("help.droplets.create_key") => t("help.droplets.create_value")
+        }, {
+          backups_enabled: { boolean: true },
+          private_networking: { boolean: true },
+          ssh_key_ids: {}
+        }
+
+        do_route /^do\s+droplets?\s+delete\s+\d+/i, :delete, {
+          t("help.droplets.delete_key") => t("help.droplets.delete_value")
+        }, { scrub: { boolean: true } }
+
+        do_route /^do\s+droplets?\s+list$/i, :list, {
+          t("help.droplets.list_key") => t("help.droplets.list_value")
+        }
+
+        do_route /^do\s+droplets?\s+password\s+reset\s+\d+$/i, :password_reset, {
+          t("help.droplets.password_reset_key") => t("help.droplets.password_reset_value")
+        }
+
+        do_route /^do\s+droplets?\s+power\s+cycle\s+\d+$/i, :power_cycle, {
+          t("help.droplets.power_cycle_key") => t("help.droplets.power_cycle_value")
+        }
+
+        do_route /^do\s+droplets?\s+power\s+off\s+\d+$/i, :power_off, {
+          t("help.droplets.power_off_key") => t("help.droplets.power_off_value")
+        }
+
+        do_route /^do\s+droplets?\s+power\s+on\s+\d+$/i, :power_on, {
+          t("help.droplets.power_on_key") => t("help.droplets.power_on_value")
+        }
+
+        do_route /^do\s+droplets?\s+reboot\s+\d+$/i, :reboot, {
+          t("help.droplets.reboot_key") => t("help.droplets.reboot_value")
+        }
+
+        do_route /^do\s+droplets?\s+rebuild(?:\s+\d+){2}$/i, :rebuild, {
+          t("help.droplets.rebuild_key") => t("help.droplets.rebuild_value")
+        }
+
+        do_route /^do\s+droplets?\s+resize\s+\d+\s+[^\s]+$/i, :resize, {
+          t("help.droplets.resize_key") => t("help.droplets.resize_value")
+        }
+
+        do_route /^do\s+droplets?\s+restore(?:\s+\d+){2}$/i, :restore, {
+          t("help.droplets.restore_key") => t("help.droplets.restore_value")
+        }
+
+        do_route /^do\s+droplets?\s+show\s+\d+$/i, :show, {
+          t("help.droplets.show_key") => t("help.droplets.show_value")
+        }
+
+        do_route /^do\s+droplets?\s+shut\s*down\s+(\d+)$/i, :shutdown, {
+          t("help.droplets.shutdown_key") => t("help.droplets.shutdown_value")
+        }
+
+        do_route /^do\s+droplets?\s+snapshot\s+\d+/i, :snapshot, {
+          t("help.droplets.snapshot_key") => t("help.droplets.snapshot_value")
+        }
+
+        def create(response)
+          name, size, image, region = response.args[2..5]
+          kwargs = response.extensions[:kwargs].dup
+          kwargs.each { |k, v| kwargs.delete(k) if v.nil? }
+
+          numeric = /^\d+$/
+
+          size_key = size =~ numeric ? :size_id : :size_slug
+          image_key = image =~ numeric ? :image_id : :image_slug
+          region_key = region =~ numeric ? :region_id : :region_slug
+
+          options = {
+            name: name,
+            size_key => size,
+            image_key => image,
+            region_key => region
+          }.merge(kwargs)
+
+          do_response = do_call(response) do |client|
+            client.droplets.create(options)
+          end or return
+
+          response.reply(t("droplets.create.created", do_response[:droplet]))
+        end
+
+        def delete(response)
+          id = response.args[2]
+          options = {}
+          options[:scrub_data] = true if response.extensions[:kwargs][:scrub]
+
+          do_response = do_call(response) do |client|
+            client.droplets.delete(id, options)
+          end or return
+
+          response.reply(t("droplets.delete.deleted", id: id))
+        end
+
+        def list(response)
+          do_response = do_call(response) do |client|
+            client.droplets.list
+          end or return
+
+          messages = do_response[:droplets].map { |droplet| t("droplets.list.detail", droplet) }
+
+          response.reply(*messages)
+        end
+
+        def password_reset(response)
+          id = response.args[3]
+
+          do_response = do_call(response) do |client|
+            client.droplets.password_reset(id)
+          end or return
+
+          response.reply(t("droplets.password_reset.reset", id: id))
+        end
+
+        def power_cycle(response)
+          id = response.args[3]
+
+          do_response = do_call(response) do |client|
+            client.droplets.power_cycle(response.args[3])
+          end or return
+
+          response.reply(t("droplets.power_cycle.cycled", id: id))
+        end
+
+        def power_off(response)
+          id = response.args[3]
+
+          do_response = do_call(response) do |client|
+            client.droplets.power_off(response.args[3])
+          end or return
+
+          response.reply(t("droplets.power_off.powered_off", id: id))
+        end
+
+        def power_on(response)
+          id = response.args[3]
+
+          do_response = do_call(response) do |client|
+            client.droplets.power_on(response.args[3])
+          end or return
+
+          response.reply(t("droplets.power_on.powered_on", id: id))
+        end
+
+        def reboot(response)
+          id = response.args[2]
+
+          do_response = do_call(response) do |client|
+            client.droplets.reboot(response.args[2])
+          end or return
+
+          response.reply(t("droplets.reboot.rebooted", id: id))
+        end
+
+        def rebuild(response)
+          id, image_id = response.args[2..3]
+
+          do_response = do_call(response) do |client|
+            client.droplets.rebuild(id, image_id: image_id)
+          end or return
+
+          response.reply(t("droplets.rebuild.rebuilt", id: id))
+        end
+
+        def resize(response)
+          id, size = response.args[2..3]
+          size_key = size =~ /^\d+$/ ? :size_id : :size_slug
+
+          do_response = do_call(response) do |client|
+            client.droplets.resize(id, size_key => size)
+          end or return
+
+          response.reply(t("droplets.resize.resized", id: id))
+        end
+
+        def restore(response)
+          id, image_id = response.args[2..3]
+
+          do_response = do_call(response) do |client|
+            client.droplets.restore(id, image_id: image_id)
+          end or return
+
+          response.reply(t("droplets.restore.restored", id: id))
+        end
+
+        def show(response)
+          do_response = do_call(response) do |client|
+            client.droplets.show(response.args[2])
+          end or return
+
+          response.reply(t("droplets.show.details", formatted_droplet(do_response[:droplet])))
+        end
+
+        def shutdown(response)
+          id = response.matches[0][0]
+
+          do_response = do_call(response) do |client|
+            client.droplets.shutdown(id)
+          end or return
+
+          response.reply(t("droplets.shutdown.shut_down", id: id))
+        end
+
+        def snapshot(response)
+          id, name = response.args[2..3]
+          options = {}
+          options[:name] = name if name
+
+          do_response = do_call(response) do |client|
+            client.droplets.snapshot(id, options)
+          end or return
+
+          response.reply(t("droplets.snapshot.snapshotted", id: id))
+        end
+
+        private
+
+        def formatted_droplet(droplet)
+          Hashie::Mash.new droplet.merge(
+            formatted_backups: format_array(droplet[:backups]),
+            formatted_snapshots: format_array(droplet[:snapshots])
+          )
+        end
+      end
+
+      Lita.register_handler(Droplet)
+    end
+  end
+end

data/lib/lita/handlers/digitalocean/image.rb

@@ -0,0 +1,68 @@
+module Lita
+  module Handlers
+    class Digitalocean < Handler
+      class Image < Base
+        do_route /^do\s+images?\s+delete\s+([^\s]+)$/i, :delete, {
+          t("help.images.delete_key") => t("help.images.delete_value")
+        }
+
+        do_route /^do\s+images?\s+list\s*.*$/i, :list, {
+          t("help.images.list_key") => t("help.images.list_value")
+        }
+
+        do_route /^do\s+images?\s+show\s([^\s]+)$/i, :show, {
+          t("help.images.show_key") => t("help.images.show_value")
+        }
+
+        def delete(response)
+          image_id = response.args[2]
+
+          do_response = do_call(response) do |client|
+            client.images.delete(image_id)
+          end or return
+
+          response.reply(t("images.delete.deleted", image_id: image_id))
+        end
+
+        def list(response)
+          filter = response.args[2]
+          normalized_filter = filter.to_s.downcase
+          options = {}
+
+          if filter && %(global my_images).include?(normalized_filter)
+            options[:filter] = normalized_filter
+          end
+
+          do_response = do_call(response) do |client|
+            client.images.list(options)
+          end or return
+
+          messages = do_response[:images].map { |image| t("images.details", formatted_image(image)) }
+
+          response.reply(*messages)
+        end
+
+        def show(response)
+          image_id = response.args[2]
+
+          do_response = do_call(response) do |client|
+            client.images.show(image_id)
+          end or return
+
+          response.reply(t("images.details", formatted_image(do_response[:image])))
+        end
+
+        private
+
+        def formatted_image(image)
+          Hashie::Mash.new image.merge(
+            formatted_regions: format_array(image[:regions]),
+            formatted_region_slugs: format_array(image[:region_slugs])
+          )
+        end
+      end
+
+      Lita.register_handler(Image)
+    end
+  end
+end