gclouder 0.1.1

data/lib/gclouder/logging.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+
+require "stringio"
+require "logger"
+
+module GClouder
+  module Logging
+    class << self
+      attr_accessor :appenders
+    end
+
+    @@good    ||= 0
+    @@bad     ||= 0
+    @@add     ||= 0
+    @@change  ||= 0
+    @@remove  ||= 0
+    @@warning ||= 0
+
+    def self.loggers
+      @loggers ||= setup
+    end
+
+    def self.included(klass)
+      klass.extend Logging
+    end
+
+    def self.setup
+      appenders.map do |appender|
+        appender[:appender].formatter = appender[:format]
+        appender[:appender].level = Logger::DEBUG
+        appender[:appender]
+      end
+    end
+
+    def self.log(message, level: :info, indent: 0, heading: false, title: false)
+      loggers.each do |log|
+        message = case message
+        when "" || nil
+          [ "" ]
+        when String
+          message.split("\n")
+        when Array
+          message
+        else
+          fatal "unknown message type: #{message.class}"
+        end
+
+        message = [ "", "" ] + message if title
+        message = [ "" ] + message if heading
+
+        if title
+          prefix = "  " * 1
+        else
+          prefix = "  " * indent
+        end
+
+        message.each { |line| log.send(level, prefix + line) }
+      end
+    end
+
+    def self.appenders
+      @appenders ||= [Appenders.stdout, Appenders.file]
+    end
+
+    module Appenders
+      def self.stdout
+        {
+          appender: ::Logger.new(STDOUT),
+          format: proc { |_, _, _, message| "#{message}\n" }
+        }
+      end
+
+      def self.file
+        {
+          appender: ::Logger.new(File.join(File.dirname(__FILE__), "../../log.txt")),
+          format: proc { |severity, datetime, _, message| "#{severity} - #{datetime}: #{message}\n" }
+        }
+      end
+
+      def self.stringio(obj = StringIO.new)
+        {
+          appender: ::Logger.new(StringIO.new),
+          format: proc { |severity, datetime, _, message| "#{severity} - #{datetime}: #{message}\n" }
+        }
+      end
+    end
+
+    def debug(message = "")
+      Logging.log message, level: :debug
+    end
+
+    def info(message = "", indent: 0, heading: false, title: false)
+      Logging.log message, level: :info, indent: indent, heading: heading, title: title
+    end
+
+    def warn(message = "", heading: false)
+      Logging.log message, level: :warn, heading: heading
+    end
+
+    def error(message = "", heading: false)
+      Logging.log message, level: :error, heading: heading
+    end
+
+    def fatal(message = "", status: 1, heading: false)
+      Logging.log "\n#{message}", level: :fatal, heading: heading
+      exit status
+    end
+
+    def resource_state(message, indent: 0, heading: false, level: :info)
+      Logging.log "#{'  ' * indent}#{message}", level: level, heading: heading
+    end
+
+    def good(message, indent: 3, heading: false)
+      @@good += 1
+      resource_state("#{Symbols.tick} #{message}", indent: indent, heading: heading)
+    end
+
+    def bad(message, indent: 3, heading: false)
+      @@bad += 1
+      resource_state("#{Symbols.x} #{message}", indent: indent, heading: heading)
+    end
+
+    def add(message, indent: 3, heading: false)
+      @@add += 1
+      resource_state("#{Symbols.plus} #{message}", indent: indent, heading: heading)
+    end
+
+    def change(message, indent: 3, heading: false)
+      @@change += 1
+      resource_state("#{Symbols.o} #{message}", indent: indent, heading: heading)
+    end
+
+    def remove(message, indent: 3, heading: false)
+      @@remove += 1
+      resource_state("#{Symbols.minus} #{message}", indent: indent, heading: heading)
+    end
+
+    def warning(message, indent: 3, heading: false)
+      @@warning += 1
+      resource_state("#{Symbols.bang} #{message}", indent: indent, heading: heading)
+    end
+
+    module Symbols
+      def self.tick
+        "✓".green
+      end
+
+      def self.x
+        "✗".red
+      end
+
+      def self.plus
+        "+".blue
+      end
+
+      def self.o
+        "o".yellow
+      end
+
+      def self.minus
+        "-".red
+      end
+
+      def self.bang
+        "!".yellow
+      end
+    end
+
+    def self.report
+      Logging.log "\n\n  [report]"
+      Logging.log " "
+      Logging.log "    #{Symbols.tick} - #{@@good}"
+      Logging.log "    #{Symbols.bang} - #{@@warning}"
+      Logging.log "    #{Symbols.x} - #{@@bad}"
+      Logging.log " "
+      Logging.log "    #{Symbols.plus} - #{@@add}"
+      Logging.log "    #{Symbols.o} - #{@@change}"
+      Logging.log "    #{Symbols.minus} - #{@@remove}"
+    end
+  end
+end

data/lib/gclouder/mappings/argument.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require "yaml"
+
+module GClouder
+  module Mappings
+    module Argument
+      include GClouder::Logging
+
+      def self.mappings
+        GClouder::ConfigLoader.load("../../assets/mappings/argument")
+      end
+
+      def self.load
+        mappings
+      end
+
+      def mappings
+        Argument.mappings
+      end
+
+      def self.included(klass)
+        klass.extend Argument
+      end
+
+      def self.section(section)
+        GClouder::ConfigSection.find(section, mappings)
+      end
+    end
+  end
+end

data/lib/gclouder/mappings/file.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require "yaml"
+
+module GClouder
+  module Mappings
+    module File
+      include GClouder::Logging
+
+      def self.mappings
+        GClouder::ConfigLoader.load("../../assets/mappings/file")
+      end
+
+      def self.load
+        mappings
+      end
+
+      def file
+        File.mappings
+      end
+
+      def self.included(klass)
+        klass.extend File
+      end
+
+      def self.section(section)
+        GClouder::ConfigSection.find(section, mappings)
+      end
+    end
+  end
+end

data/lib/gclouder/mappings/property.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require "yaml"
+
+module GClouder
+  module Mappings
+    module Property
+      include GClouder::Logging
+
+      def self.mappings
+        YAML.load_file(::File.join(::File.dirname(__FILE__), "../../../assets/mappings/property.yml"))
+      end
+
+      def self.load
+        mappings
+      end
+
+      def mappings
+        Property.mappings
+      end
+
+      def self.included(klass)
+        klass.extend Property
+      end
+
+      def self.section(section)
+        GClouder::ConfigSection.find(section, mappings)
+      end
+    end
+  end
+end

data/lib/gclouder/mappings/resource_representation.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require "yaml"
+
+module GClouder
+  module Mappings
+    module ResourceRepresentation
+      include GClouder::Logging
+
+      def self.mappings
+        GClouder::ConfigLoader.load("../../assets/resource_representations")
+      end
+
+      def self.load
+        mappings
+      end
+
+      def resource_representation
+        ResourceRepresentation.mappings
+      end
+
+      def self.included(klass)
+        klass.extend ResourceRepresentation
+      end
+
+      def self.section(section)
+        GClouder::ConfigSection.find(section, mappings)
+      end
+    end
+  end
+end

data/lib/gclouder/monkey_patches/array.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+class Array
+  def clean
+    uniq.delete_if(&:nil?)
+  end
+
+  def to_snake_keys
+    each_with_index do |v, i|
+      self[i] = v.to_snake_keys if v.is_a?(Hash)
+    end
+    self
+  end
+
+  def fetch_with_default(key, name, default)
+    results = find { |e| e[key] == name }
+    results || default
+  end
+end

data/lib/gclouder/monkey_patches/boolean.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+module Boolean
+end
+
+class TrueClass
+  include Boolean
+end
+
+class FalseClass
+  include Boolean
+end

data/lib/gclouder/monkey_patches/hash.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+class Hash
+  # sourced from: https://github.com/futurechimp/plissken/blob/master/lib/plissken/ext/hash/to_snake_keys.rb
+  def to_snake_keys(value = self)
+    case value
+    when Array
+      value.map { |v| to_snake_keys(v) }
+    when Hash
+      snake_hash(value)
+    else
+      value
+    end
+  end
+
+  private
+
+  def snake_hash(value)
+    Hash[value.map { |k, v| [underscore_key(k), to_snake_keys(v)] }]
+  end
+
+  def underscore_key(k)
+    if k.is_a? Symbol
+      underscore(k.to_s)
+    elsif k.is_a? String
+      underscore(k)
+    else
+      k
+    end
+  end
+
+  def underscore(string)
+    string.gsub(/::/, '/')
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .tr('-', '_')
+      .downcase
+  end
+end
+
+class DeepMergeHash < Hash
+  include Hashie::Extensions::MergeInitializer
+  include Hashie::Extensions::DeepMerge
+end

data/lib/gclouder/monkey_patches/ipaddr.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+class IPAddr
+  def self.valid?(obj)
+    IPAddr.new(obj)
+    true
+  rescue IPAddr::InvalidAddressError
+    false
+  end
+end

data/lib/gclouder/monkey_patches/string.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+class String
+  include GClouder::Shell
+
+  def snakecase
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+  def mixedcase
+    self.split('_').collect(&:capitalize).join.sub(/^[A-Z]/, &:downcase)
+  end
+
+  def truncate(length = 32)
+    raise 'Pleasant: Length should be greater than 3' unless length > 3
+
+    truncated_string = self.to_s
+
+    if truncated_string.length > length
+      truncated_string = truncated_string[0...(length - 3)]
+      truncated_string += "..."
+    end
+
+    truncated_string
+  end
+end

data/lib/gclouder/resource.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+module GClouder
+  module Resource
+    include GClouder::GCloud
+    include GClouder::Config::CLIArgs
+    include GClouder::Logging
+
+    def self.feedback(action, resource, name, extra_info: nil, indent: 3, silent: false)
+      return if silent
+      send action, "#{name} #{extra_info}", indent: indent
+    end
+
+    def self.resource?(resource, name, args = nil, filter_key: "name", filter: "#{filter_key} ~ ^#{name}$", project_id: nil, silent: false, extra_info: nil, indent: 3)
+      exists = \
+        gcloud("#{resource} list --filter '#{filter}' #{args} | jq '. | length'", force: true, silent: silent, project_id: project_id)
+
+      if exists
+        feedback("good", resource, name, extra_info: extra_info, indent: indent, silent: silent)
+        return true
+      end
+
+      false
+    end
+
+    def self.describe(resource, name, args = nil, force: true, failure: true, silent: false, project_id: nil)
+      return if resource?(resource, name, silent: silent, project_id: project_id)
+      gcloud "#{resource} describe #{name} #{args}", force: force, failure: failure, silent: silent, project_id: project_id
+    end
+
+    def self.ensure(resource, name, args = nil, project_id: nil, extra_info: nil, silent: false, indent: 3, filter_key: "name")
+      return if resource?(resource, name, project_id: project_id, extra_info: extra_info, silent: silent, indent: indent, filter_key: filter_key)
+      feedback("add", resource, name, extra_info: extra_info, indent: indent, silent: silent)
+      gcloud "#{resource} create #{name} #{args}", project_id: project_id, silent: silent
+    end
+
+    def self.purge(resource, name, args = nil, project_id: nil, silent: false, indent: 3)
+      return unless resource?(resource, name, project_id: project_id, silent: true, indent: indent)
+      extra_info = "[skipped] (--purge not specified)" unless cli_args[:purge]
+      feedback("remove", resource, name, extra_info: extra_info, indent: indent, silent: silent)
+      gcloud "#{resource} delete #{name} #{args}", project_id: project_id if cli_args[:purge]
+    end
+
+    def self.list(resource, args = nil, snake_case: false, project_id: nil)
+      list = gcloud "#{resource} list #{args}", force: true, project_id: project_id
+      snake_case ? list.to_snake_keys : list
+    end
+
+    module Find
+      include GClouder::GCloud
+
+      def self.zone(resource, name, region, project_id: nil)
+        zones = %w(b c d).map { |zone| region + "-" + zone }
+
+        zones.each do |zone|
+          return zone if gcloud "#{resource} describe #{name} --zone=#{zone}", force: true, failure: false, silent: true, project_id: project_id
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/gclouder/resource_cleaner.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+module GClouder
+  module Resource
+    module Cleaner
+      def self.included(klass)
+        klass.extend Cleaner
+      end
+
+      def clean
+        return if undefined.empty?
+
+        header :clean
+
+        undefined.each do |namespace, resources|
+          info namespace, indent: 2, heading: true
+          info
+          resources.each do |resource|
+            message = resource['name']
+            message += " (not defined locally)"
+            warning message
+            # FIXME: enable purge on --purge flag..
+            #Resource.symlink.send(:purge, namespace, resource)
+          end
+        end
+      end
+
+
+      module Default
+        def self.cleaner
+          Proc.new do |resources, resource|
+            resources.map do |r|
+              r['name'] == resource
+            end.include?(true)
+          end
+        end
+      end
+
+      def cleaner
+        (self.const_defined?(:Cleaner) && self::Cleaner.respond_to?(:custom)) ? self::Cleaner.custom : Default.cleaner
+      end
+
+      def undefined
+        self::Remote.list.each_with_object({}) do |(namespace, resources), collection|
+          resources.each do |resource|
+            namespace_resources = self::Local.list[namespace]
+
+            # accept PROC for custom matching of undefined resources
+            next if namespace_resources && cleaner.call(namespace_resources, resource["name"])
+
+            collection[namespace] ||= []
+            collection[namespace] << resource
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gclouder/resources/compute/addresses.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+module GClouder
+  module Resources
+    module Compute
+      module Addresses
+        include GClouder::GCloud
+        include GClouder::Logging
+        include GClouder::Resource::Cleaner
+
+        def self.header(stage = :ensure)
+          info "[#{stage}] compute / addresses", title: true
+        end
+
+        def self.ensure
+          return if Local.list.empty?
+          header
+
+          if Local.list.key?("global")
+            info "global", indent: 2, heading: true
+            info
+            Local.list["global"].each { |address| Address.ensure(address["name"], "--global") }
+          end
+
+          Local.list.each do |region, addresses|
+            next if region == "global"
+            next unless addresses
+
+            info region, indent: 2, heading: true
+            info
+            addresses.each do |address|
+              Address.ensure(address["name"], "--region #{region}")
+            end
+          end
+        end
+
+        def self.check
+          return if Remote.list.empty?
+          return if Local.list.empty?
+          header :check
+          Resources::Validate::Remote.instances(Local.list, Remote.list)
+        end
+
+        def self.validate
+          return if Local.list.empty?
+          header :validate
+          Local.validate
+        end
+
+        module Local
+          include GClouder::Config::Project
+
+          def self.list
+            addresses = global.merge regional
+            addresses.delete_if { |_k, v| v.empty? }
+          end
+
+          def self.global
+            Resources::Global.instances(path: ["addresses"])
+          end
+
+          def self.section
+            %w(compute addresses)
+          end
+
+          def self.validate
+            Resources::Validate::Region.instances(
+              list,
+              required_keys:  GClouder::Config::Arguments.required(section),
+              permitted_keys: GClouder::Config::Arguments.permitted(section)
+            )
+          end
+
+          def self.regional
+            resources = Resources::Region.instances(path: ["addresses"])
+
+            # get_instances_from_region assumes all keys have configs.. this normalizes
+            # the data to match self.global
+            resources.each { |k, v| resources[k] = v.to_a.flatten.delete_if(&:nil?) }
+          end
+        end
+
+        module Remote
+          def self.list
+            Resources::Remote.instances(
+              path: ["compute", "addresses"]
+            )
+          end
+        end
+
+        module Address
+          def self.ensure(name, args)
+            GClouder::Resource.ensure :"compute addresses", name, args
+          end
+
+          def self.purge(namespace, name, args = nil)
+          end
+        end
+
+        module Resource
+          def self.symlink
+            Module.const_get "#{self.name.delete(/::Resource$/)}::Address"
+          end
+        end
+      end
+    end
+  end
+end