doggy 0.2.2 → 2.0.0

data/lib/doggy/cli/edit.rb

@@ -1,14 +1,41 @@
 module Doggy
   class CLI::Edit
-    attr_reader :options, :id
-
-    def initialize(options, id)
+    def initialize(options, param)
       @options = options
-      @id = id
+      @param   = param
     end
 
     def run
-      Doggy.edit(id)
+      resource = resource_by_param
+      return Doggy.ui.error("Could not find resource with #{ @param }") unless resource
+
+      Dir.chdir(File.dirname(resource.path)) do
+        system("open '#{ resource.human_edit_url }'")
+        while !Doggy.ui.yes?('Are you done editing?') do
+          Doggy.ui.say "run, rabbit run / dig that hole, forget the sun / and when at last the work is done / don't sit down / it's time to dig another one"
+        end
+
+        new_resource      = resource.class.find(resource.id)
+        new_resource.path = resource.path
+        new_resource.save_local
+      end
+    end
+
+  private
+
+    def resource_by_param
+      resources  = Doggy::Models::Dashboard.all_local
+      resources += Doggy::Models::Monitor.all_local
+      resources += Doggy::Models::Screen.all_local
+
+      if @param =~ /^[0-9]+$/ then
+        id = @param.to_i
+        return resources.find { |res| res.id == id }
+      else
+        full_path = File.expand_path(@param, Dir.pwd)
+        return resources.find { |res| res.path == full_path }
+      end
     end
   end
 end
+

data/lib/doggy/cli/mute.rb

@@ -1,19 +1,14 @@
 module Doggy
   class CLI::Mute
-    attr_reader :options, :ids
-
     def initialize(options, ids)
       @options = options
-      @ids = ids
+      @ids     = ids
     end
 
     def run
-      begin
-        Doggy::Monitor.mute(ids)
-      rescue DoggyError
-        puts "Mute failed."
-        exit 1
-      end
+      monitors = @ids.map { |id| Doggy::Models::Monitor.find(id) }
+      monitors.each(&:mute)
     end
   end
 end
+

data/lib/doggy/cli/pull.rb

@@ -1,21 +1,29 @@
 module Doggy
   class CLI::Pull
-    attr_reader :options, :ids
-
-    def initialize(options, ids)
+    def initialize(options)
       @options = options
-      @ids = ids
     end
 
     def run
-      begin
-        Doggy::Dash.download(ids)
-        Doggy::Monitor.download(ids)
-        Doggy::Screen.download(ids)
-      rescue DoggyError
-        puts "Pull failed."
-        exit 1
-      end
+      pull_resources('dashboards', Models::Dashboard) if should_pull?('dashboards')
+      pull_resources('monitors',   Models::Monitor)   if should_pull?('monitors')
+      pull_resources('screens',    Models::Screen)    if should_pull?('screens')
+    end
+
+  private
+
+    def should_pull?(resource)
+      @options.empty? || @options[resource]
+    end
+
+    def pull_resources(name, klass)
+      Doggy.ui.say "Pulling #{ name }"
+      local_resources  = klass.all_local
+      remote_resources = klass.all
+
+      klass.assign_paths(remote_resources, local_resources)
+      remote_resources.each(&:save_local)
     end
   end
 end
+

data/lib/doggy/cli/push.rb

@@ -1,28 +1,26 @@
 module Doggy
   class CLI::Push
-    attr_reader :options, :ids
-
-    def initialize(options, ids)
+    def initialize(options)
       @options = options
-      @ids = ids
     end
 
     def run
-      begin
-        if ids.any?
-          Doggy::Dash.upload(ids)
-          Doggy::Monitor.upload(ids)
-          Doggy::Screen.upload(ids)
-        else
-          Doggy::Dash.upload_all
-          Doggy::Monitor.upload_all
-          Doggy::Screen.upload_all
-          Doggy.emit_shipit_deployment if ENV['SHIPIT']
-        end
-      rescue DoggyError
-        puts "Push failed."
-        exit 1
-      end
+      push_resources('dashboards', Models::Dashboard) if should_push?('dashboards')
+      push_resources('monitors',   Models::Monitor)   if should_push?('monitors')
+      push_resources('screens',    Models::Screen)    if should_push?('screens')
+    end
+
+  private
+
+    def should_push?(resource)
+      @options.empty? || @options[resource]
+    end
+
+    def push_resources(name, klass)
+      Doggy.ui.say "Pushing #{ name }"
+      local_resources = klass.all_local
+      local_resources.each(&:save)
     end
   end
 end
+

data/lib/doggy/cli/unmute.rb

@@ -1,19 +1,15 @@
 module Doggy
   class CLI::Unmute
-    attr_reader :options, :ids
-
     def initialize(options, ids)
       @options = options
-      @ids = ids
+      @ids     = ids
     end
 
     def run
-      begin
-        Doggy::Monitor.unmute(ids)
-      rescue DoggyError
-        puts "Unmute failed."
-        exit 1
-      end
+      monitors = @ids.map { |id| Doggy::Models::Monitor.find(id) }
+      monitors.each(&:unmute)
     end
   end
 end
+
+

data/lib/doggy/model.rb

@@ -0,0 +1,155 @@
+require "json"
+require "parallel"
+require "uri"
+require "virtus"
+
+module Doggy
+  class Model
+    include Virtus.model
+
+    # This stores the path on disk. We don't define it as a model attribute so
+    # it doesn't get serialized.
+    attr_accessor :path
+
+    # This stores whether the resource has been loaded locally or remotely.
+    attr_accessor :loading_source
+
+    class << self
+      def root=(root)
+        @root = root.to_s
+      end
+
+      def root
+        @root || nil
+      end
+
+      def find(id)
+        attributes = request(:get, resource_url(id))
+        resource   = new(attributes)
+
+        resource.loading_source = :remote
+        resource
+      end
+
+      def assign_paths(remote_resources, local_resources)
+        remote_resources.each do |remote|
+          local = local_resources.find { |l| l.id == remote.id }
+          next unless local
+
+          remote.path = local.path
+        end
+      end
+
+      def all
+        collection = request(:get, resource_url)
+        if collection.is_a?(Hash) && collection.keys.length == 1
+          collection = collection.values.first
+        end
+
+        ids = collection
+          .map    { |record| new(record) }
+          .select { |instance| instance.managed? }
+          .map    { |instance| instance.id }
+
+        Parallel.map(ids) { |id| find(id) }
+      end
+
+      def all_local
+        @all_local ||= begin
+                         # TODO: Add serializer support here
+                         files   = Dir[Doggy.object_root.join("**/*.json")]
+                         resources = Parallel.map(files) do |file|
+                           raw = File.read(file)
+
+                           begin
+                             attributes = JSON.parse(raw)
+                           rescue JSON::ParserError
+                             Doggy.ui.error "Could not parse #{ file }."
+                             next
+                           end
+
+                           next unless infer_type(attributes) == self
+
+                           resource                = new(attributes)
+                           resource.path           = file
+                           resource.loading_source = :local
+                           resource
+                         end
+
+                         resources.compact
+                       end
+      end
+
+      def infer_type(attributes)
+        return Models::Dashboard if attributes['graphs']
+        return Models::Monitor   if attributes['message']
+        return Models::Screen    if attributes['board_title']
+      end
+
+      def request(method, url, body = nil)
+        uri = URI(url)
+        uri.query = "api_key=#{ Doggy.api_key }&application_key=#{ Doggy.application_key }"
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == 'https')
+
+        request = case method
+                  when :get  then Net::HTTP::Get.new(uri.request_uri)
+                  when :post then Net::HTTP::Post.new(uri.request_uri)
+                  when :put  then Net::HTTP::Put.new(uri.request_uri)
+                  end
+
+        request.content_type = 'application/json'
+        request.body = body if body
+
+        response = http.request(request)
+        JSON.parse(response.body)
+      end
+
+      protected
+
+      def resource_url(id = nil)
+        raise NotImplementedError, "#resource_url has to be implemented."
+      end
+    end
+
+    def initialize(attributes = nil)
+      root_key = self.class.root
+
+      return super unless attributes && root_key
+      return super unless attributes[root_key].is_a?(Hash)
+
+      attributes = attributes[root_key]
+      super(attributes)
+    end
+
+    def save_local
+      @path ||= Doggy.object_root.join("#{ id }.json")
+      File.open(@path, 'w') { |f| f.write(JSON.pretty_generate(to_h)) }
+    end
+
+    def save
+      ensure_managed_emoji!
+
+      body = JSON.dump(to_h)
+      if !id then
+        attributes = request(:post, resource_url, body)
+        self.id    = self.class.new(attributes).id
+        save_local
+      else
+        request(:put, resource_url(id), body)
+      end
+    end
+
+    protected
+
+    def resource_url(id = nil)
+      self.class.resource_url(id)
+    end
+
+    def request(method, uri, body = nil)
+      self.class.request(method, uri, body)
+    end
+  end # Model
+end # Doggy
+

data/lib/doggy/models/dashboard.rb

@@ -0,0 +1,37 @@
+module Doggy
+  module Models
+    class Dashboard < Doggy::Model
+      self.root = 'dash'
+
+      attribute :id,          Integer
+      attribute :title,       String
+      attribute :description, String
+
+      attribute :graphs,             Array[Hash]
+      attribute :template_variables, Array[Hash]
+
+      def self.resource_url(id = nil)
+        "https://app.datadoghq.com/api/v1/dash".tap do |base_url|
+          base_url << "/#{ id }" if id
+        end
+      end
+
+      def managed?
+        !(title =~ Doggy::DOG_SKIP_REGEX)
+      end
+
+      def ensure_managed_emoji!
+        return unless managed?
+        self.title += " \xF0\x9F\x90\xB6"
+      end
+
+      def human_url
+        "https://app.datadoghq.com/dash/#{ id }"
+      end
+
+      # Dashboards don't have a direct edit URL
+      alias_method :human_edit_url, :human_url
+    end # Dashboard
+  end # Models
+end # Doggy
+

data/lib/doggy/models/monitor.rb

@@ -0,0 +1,82 @@
+module Doggy
+  module Models
+    class Monitor < Doggy::Model
+      class Options
+        include Virtus.model
+        attr_accessor :monitor
+
+        attribute :silenced,           Hash
+        attribute :notify_audit,       Boolean
+        attribute :notify_no_data,     Boolean
+        attribute :no_data_timeframe,  Integer
+        attribute :timeout_h,          Integer
+        attribute :escalation_message, String
+
+        def to_h
+          return super unless monitor.id && monitor.loading_source == :local
+
+          # Pull remote silenced state. If we don't send this value, Datadog
+          # assumes that we want to unmute the monitor.
+          remote_monitor = Monitor.find(monitor.id)
+          self.silenced  = remote_monitor.options.silenced
+          super
+        end
+      end
+
+      attribute :id,     Integer
+      attribute :org_id, Integer
+      attribute :name,   String
+
+      attribute :message, String
+      attribute :query,   String
+      attribute :options, Options
+      attribute :tags,    Array[String]
+      attribute :type,    String
+      attribute :multi,   Boolean
+
+      def self.resource_url(id = nil)
+        "https://app.datadoghq.com/api/v1/monitor".tap do |base_url|
+          base_url << "/#{ id }" if id
+        end
+      end
+
+      def initialize(attributes = nil)
+        super(attributes)
+
+        options.monitor = self
+      end
+
+      def managed?
+        !(name =~ Doggy::DOG_SKIP_REGEX)
+      end
+
+      def ensure_managed_emoji!
+        return unless managed?
+        self.name += " \xF0\x9F\x90\xB6"
+      end
+
+      def mute
+        return unless id
+        request(:post, "#{ resource_url(id) }/mute")
+      end
+
+      def unmute
+        return unless id
+        request(:post, "#{ resource_url(id) }/unmute")
+      end
+
+      def human_url
+        "https://app.datadoghq.com/monitors##{ id }"
+      end
+
+      def human_edit_url
+        "https://app.datadoghq.com/monitors##{ id }/edit"
+      end
+
+      def to_h
+        super.merge(options: options.to_h)
+      end
+    end # Monitor
+  end # Models
+end # Doggy
+