mystro-common 0.1.0

data/lib/mystro/connect.rb

@@ -0,0 +1,123 @@
+module Mystro
+  module Connect
+    class Base
+      class << self
+        attr_accessor :model
+        attr_accessor :collection
+
+        def cname
+          self.name.split("::").last.downcase
+        end
+
+        def fog
+          Mystro.send(cname).fog || nil rescue nil
+        end
+
+        def after(event, &block)
+          @hooks ||= {}
+          @hooks[event] ||= []
+          @hooks[event] << block
+        end
+
+        def hooks(event, *args)
+          Mystro::Log.debug "#{cname}:hooks:#{event} #{@hooks[event].count}"
+          @hooks[event].each do |e|
+            Mystro::Log.debug "#{cname}:hooks:#{event} #{e}"
+            e.call(*args) if e
+          end
+        end
+      end
+
+      attr_reader :cfg
+      attr_reader :opt
+      attr_reader :fog
+
+      def initialize(account)
+        a = account.data
+        c = cname
+
+        # opt is used to initialize fog in connect classes
+        defaults = a.connect!.fog? ? a.connect.fog : {}
+        overrides = a[c] && a[c].fog? ? a[c].fog : {}
+        raw = defaults.deep_merge(overrides)
+        @opt = Hashie::Mash.new(raw)
+
+        # cfg is the additional configuration parms (aside from the fog block)
+        raw = {}
+        if a[c]
+          raw = a[c].to_hash
+          raw.delete(:fog) if raw[:fog]
+        end
+        @cfg = Hashie::Mash.new(raw)
+
+        self.class.after :create do |e, model|
+          Mystro::Plugin.run "#{cname}:create", e, model
+        end
+
+        self.class.after :destroy do |e, tags|
+          Mystro::Plugin.run "#{cname}:destroy", e, tags
+        end
+
+        connect
+      end
+
+      def connect
+        @fog ||= model.new(opt) if opt
+      rescue => e
+        Mystro::Log.error "#{cname} connect failed: #{e.message} at #{e.backtrace.first}"
+      end
+
+      def connected?
+        fog.nil? ? false : true
+      end
+
+      def find(id)
+        fog.send(collection).get(id)
+      end
+
+      def all
+        fog.send(collection).all
+      end
+
+      def create(model)
+        Mystro::Log.debug "#{cname}#create #{model.inspect}"
+        Mystro::Log.debug "#{cname}#create #{fog.inspect}"
+        e = fog.send(collection).create(model.fog_options)
+        e
+      end
+
+      def destroy(models)
+        list = [*models].flatten
+        list.each do |m|
+          Mystro::Log.debug "#{cname}#destroy #{m.rid}"
+          e = find(m.rid)
+          e.destroy if e
+        end
+      end
+
+      def model
+        raise "model not set for '#{cname}'" unless self.class.model
+        @model ||= self.class.model.constantize
+      end
+
+      def collection
+        raise "collection not set for '#{cname}'" unless self.class.collection
+        @collection ||= self.class.collection
+      end
+
+      def cname
+        self.class.cname
+      end
+
+      def after(*args)
+        self.class.after(*args)
+      end
+
+      def hooks(*args)
+        self.class.hooks(*args)
+      end
+    end
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/connect/*.rb"].each {|file| require "#{file.gsub(/\.rb/,'')}" }

data/lib/mystro/dsl/template.rb

@@ -0,0 +1,281 @@
+module Mystro
+  module DSL
+    module Template
+      class << self
+        def load(name_or_file)
+          @templates    ||= {}
+          template_name = nil
+          template_file = nil
+          if File.exists?(name_or_file)
+            template_name = File.basename(name_or_file).gsub(/\.rb$/, "").to_sym
+            template_file = name_or_file
+          elsif File.exists?("#{dir}/#{name_or_file}.rb")
+            template_name = name.to_sym
+            template_file = "#{dir}/#{name}.rb"
+          end
+          raise "could not load template #{template_name} (#{template_file})" unless template_file && File.file?(template_file)
+          #raise "template already loaded #{template_name}" if @templates[template_name]
+          @templates[template_name] ||= begin
+            t = Mystro::DSL::Template::DSL.new(template_name)
+            t.instance_eval(File.read(template_file), "Template(#{template_file})")
+            @templates[template_name] = t
+          end
+        end
+
+        def load_yaml_file(path)
+          file = File.expand_path(path)
+          raise "Configuration not found: #{path} (#{file})" unless File.exists?(file)
+          yaml = YAML.load_file(file)
+          yaml = yaml[yaml.keys.first] if yaml.keys.count == 1
+
+          yaml
+        end
+
+        def list
+          Dir["#{dir}/*"].inject({}) do |h, e|
+            f           = e.gsub("#{dir}/", "")
+            f           = File.basename(f, ".yml")
+            h[f.to_sym] = e
+            h
+          end
+        end
+
+        private
+        def dir
+          "#{Mystro.directory}/templates"
+        end
+      end
+
+      class DSL
+        attr_reader :balancers, :servers
+
+        def initialize(name)
+          @name      = name.to_sym
+          @balancers = []
+          @servers   = []
+        end
+
+        def template(&block)
+          instance_eval &block
+        end
+
+        def balancer(name, &block)
+          balancer = Balancer.new(name)
+          balancer.instance_eval &block
+          @balancers << balancer
+        end
+
+        def server(name, &block)
+          server = Server.new(name)
+          server.instance_eval &block
+          @servers << server
+        end
+      end
+
+      class Base
+        def attr(name, value=nil)
+          @attrs[name] = value unless value.nil?
+          @attrs[name]
+        end
+
+        def list_attr(name, value=nil)
+          @attrs[name] ||= []
+          unless value.nil?
+            if value.kind_of?(Array)
+              @attrs[name] += value
+            else
+              @attrs[name] << value
+            end
+          end
+          @attrs[name]
+        end
+      end
+
+      class Server < Base
+        def initialize(name)
+          @attrs = {
+              :name     => name.to_sym,
+              :roles    => [],
+              :groups   => [],
+              :count    => 1,
+              :image    => nil,
+              :flavor   => nil,
+              :keypair  => nil,
+              :userdata => "default",
+              :dnsnames => [],
+          }
+        end
+
+        def name
+          @attrs[:name]
+        end
+
+        def roles
+          @attrs[:roles]
+        end
+
+        def groups
+          @attrs[:groups]
+        end
+
+        def dnsnames
+          @attrs[:dnsnames]
+        end
+
+        def role(r)
+          list_attr(:roles, r)
+        end
+
+        def count(c=nil)
+          attr(:count, c)
+        end
+
+        def image(i=nil)
+          attr(:image, i)
+        end
+
+        def flavor(f=nil)
+          attr(:flavor, f)
+        end
+
+        def group(g)
+          list_attr(:groups, g)
+        end
+
+        def keypair(k=nil)
+          attr(:keypair, k)
+        end
+
+        def userdata(u=nil)
+          attr(:userdata, u)
+        end
+
+        def balancer(b=nil, &block)
+          if block_given?
+            raise "balancer block must specify name" unless b
+            Mystro::DSL::Template::DSL.balancer(b, &block)
+          end
+          attr(:balancer, b)
+        end
+
+        def dns(name)
+          n = name.gsub(Mystro.get_config(:dns_zone), "")
+          list_attr(:dnsnames, n)
+        end
+      end
+
+      class Balancer
+        attr_reader :name, :sticky, :primary, :sticky_type, :sticky_arg
+
+        def initialize(name)
+          @listeners = []
+          @name      = name.to_sym
+          @primary   = false
+          @sticky    = false
+        end
+
+        def primary(enable = nil)
+          enable.nil? ? @primary : @primary = enable
+        end
+
+        def listener(&block)
+          listener = Listener.new
+          listener.instance_eval &block
+          @listeners << listener
+        end
+
+        def health(&block)
+          healthcheck = HealthCheck.new
+          healthcheck.instance_eval &block
+          @healthcheck = healthcheck
+        end
+
+        def listeners
+          @listeners.map { |e| e.spec }
+        end
+
+        def sticky(type=nil, expires_or_cookie=nil)
+          if type && expires_or_cookie
+            @sticky      = true
+            @sticky_type = type
+            @sticky_arg  = expires_or_cookie
+          end
+          @sticky
+        end
+      end
+
+      class Listener
+        def initialize
+          @from_proto = nil
+          @from_port  = nil
+          @to_proto   = nil
+          @to_port    = nil
+          @cert       = nil
+        end
+
+        def from(proto, port)
+          @from_proto = proto
+          @from_port  = port
+        end
+
+        def to(proto, port)
+          @to_proto = proto
+          @to_port  = port
+        end
+
+        def cert(cert)
+          @cert = cert
+        end
+
+        def spec
+          {
+              :from => "#@from_proto:#@from_port",
+              :to   => "#@to_proto:#@to_port",
+              :cert => @cert,
+          }
+        end
+      end
+
+      class HealthCheck
+        def initialize
+          @healthy   = 10
+          @unhealthy = 2
+          @interval  = 30
+          @target    = nil
+          @timeout   = 5
+        end
+
+        def healthy(v)
+          @healthy = v
+        end
+
+        def unhealthy(v)
+          @unhealthy = v
+        end
+
+        def interval(v)
+          @interval = v
+        end
+
+        def target(v)
+          @target = v
+        end
+
+        def timeout(v)
+          @timeout = v
+        end
+
+        def spec
+          raise "target not specified for health check" unless @target
+          {
+              healthy: @healthy,
+              unhealthy: @unhealthy,
+              interval: @interval,
+              target: @target,
+              timeout: @timeout,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/mystro/ext/fog/balancer.rb

@@ -0,0 +1,15 @@
+# make load balancers act more like other models in Fog
+# ultimately a hack, but makes things work for now.
+module Fog
+  class Balancer
+    def self.new(attributes)
+      attributes = attributes.dup
+      case provider = attributes.delete(:provider).to_s.downcase.to_sym
+        when :aws
+          Fog::AWS::ELB.new(attributes)
+        else
+          raise ArgumentError.new("#{provider} is not a recognized balancer provider")
+      end
+    end
+  end
+end

data/lib/mystro/log.rb

@@ -0,0 +1,58 @@
+require "yell"
+
+module Mystro
+  class Log
+    class << self
+      attr_reader :loggers
+
+      def init
+        @loggers           = { }
+        @loggers["STDOUT"] = Yell.new(STDOUT, :level => [:info, :warn], :format => Yell::NoFormat)
+        @loggers["STDERR"] = Yell.new(STDERR, :level => [:error, :fatal], :format => Yell::NoFormat)
+        #@loggers["/tmp/mystro.log"] = Yell.new(:datefile, "/tmp/mystro.log", :level => :debug, :format => Yell::DefaultFormat, :keep => 7, :symlink => true)
+      end
+
+      def add(level, dest, format=Yell::DefaultFormat)
+        if [STDOUT, STDERR].include?(dest)
+          console_disable
+          @loggers["STDOUT"] = Yell.new(dest, :level => level, :format => format)
+        else
+          @loggers.delete(dest) if @loggers[dest]
+          FileUtils.mkdir_p(File.dirname(dest))
+          @loggers[dest] = Yell.new(:datefile, dest,
+                                    :level => level, :format => format,
+                                    :keep  => 7, :symlink => true)
+        end
+      end
+
+      def console_disable
+        %w{STDOUT STDERR}.each { |s| @loggers.delete(s) }
+      end
+
+      def console_debug
+        console_disable
+        @loggers["STDOUT"] = Yell.new(STDOUT, :level => [:debug, :info, :warn], :format => Yell::NoFormat)
+        @loggers["STDERR"] = Yell.new(STDERR, :level => [:error, :fatal], :format => Yell::NoFormat)
+      end
+
+      def console_quiet
+        console_disable
+        @loggers["STDOUT"] = Yell.new(STDOUT, :level => [:warn], :format => Yell::NoFormat)
+        @loggers["STDERR"] = Yell.new(STDERR, :level => [:error, :fatal], :format => Yell::NoFormat)
+      end
+
+      %w{debug info warn error fatal}.each do |method_name|
+        class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
+          def #{method_name}(msg=nil, &block)
+            @loggers.each {|k, l| l.#{method_name}(msg, &block) }
+          end
+        METHOD_DEFN
+      end
+
+      def reset
+        @loggers = {}
+      end
+    end
+  end
+end
+Mystro::Log.init

data/lib/mystro/model.rb

@@ -0,0 +1,71 @@
+require 'mystro-common'
+
+module Mystro
+  module Model
+    class Base
+      attr_reader :attributes
+
+      def initialize(attributes={ })
+        # all the stringify keys calls are to make sure that we normalize EVERYTHING before merges
+        d = defaults.stringify_keys!
+        c = load_from_config.stringify_keys!
+        a = attributes.stringify_keys!
+        # attributes should ALWAYS be stringified keys
+        @attributes = d.deep_merge(c).deep_merge(a).stringify_keys!
+      end
+
+      def defaults
+        self.class.defaults || {}
+      end
+
+      def fog_tags(hash=self.class.tagnames.each {|t| hash[t] = send(t) })
+        hash.inject({ }) do |h, e|
+          (k, v)                    = e
+          h["#{k.to_s.capitalize}"] = v
+          h
+        end
+      end
+
+      private
+
+      def load_from_config
+        cname    = self.class.name.split("::").last.downcase
+        config = { }
+        if Mystro.account && Mystro.account[cname]
+          config = Mystro.account[cname].to_hash
+        end
+        config["account"] = Mystro.selected
+        config
+      end
+
+      class << self
+        attr_reader :tagnames
+        attr_reader :attrnames
+        attr_reader :defaults
+
+        def attr(*list)
+          @attrnames = list
+          list.each do |a|
+            define_method(a) do
+              @attributes[a.to_s]
+            end
+            define_method("#{a}=") do |val|
+              @attributes[a.to_s] = val
+            end
+          end
+        end
+
+        def tag(*list)
+          @tagnames = list
+          attr(*list)
+        end
+
+        def default(hash)
+          @defaults = hash
+        end
+      end
+    end
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/model/*.rb"].each { |file| require file.gsub(/\.rb/, '') }

data/lib/mystro/plugin.rb

@@ -0,0 +1,73 @@
+module Mystro
+  module Plugin
+    class << self
+      def run(event, *args)
+        return if Mystro.config.mock
+
+        @hooks ||= []
+        @hooks.select { |e| e[:event] == event }.each do |plugin|
+          klass = plugin[:class]
+          block = plugin[:block]
+          begin
+            Mystro::Log.debug "calling #{klass} :: #{event}"
+            block.call(args.dup)
+          rescue => e
+            Mystro::Log.error "failed to run event #{event} for #{klass}: #{e.message}"
+            Mystro::Log.debug e
+          end
+        end
+      end
+
+      def on(klass, event, &block)
+        @hooks ||= []
+        @hooks << { :event => event, :class => klass, :block => block }
+      end
+
+      def load(plugins={ })
+        plugins.each do |plugin, data|
+          begin
+            f = "#{Mystro.directory}/plugins/#{plugin}"
+            Mystro::Log.debug "loading plugin: #{plugin} #{f}"
+            require f
+          rescue LoadError, StandardError => e
+            Mystro::Log.error "error while loading plugin: #{plugin}: #{e.message} at #{e.backtrace.first}"
+          end
+        end
+      end
+
+      def register(plugin, type, klass)
+        @plugins ||= {}
+        @plugins[type] ||= {}
+        @plugins[type][plugin] = klass
+      end
+    end
+
+    module Base
+      def self.included(base)
+        base.extend self
+      end
+
+      def config_for(klass)
+        name = klass.name.split('::').last.downcase.to_sym
+        return Mystro.account.plugins[name] if Mystro.account.plugins && Mystro.account.plugins[name]
+        { }
+      end
+
+      def on(event, &block)
+        Mystro::Plugin.on(self, event, &block)
+      end
+
+      def command(name, desc, klass=nil, &block)
+        on "commands:loaded" do |args|
+          Mystro::Log.debug "loading commands for #{name}"
+          command = args.shift
+          if klass
+            command.subcommand name, "#{desc} (#{self})", klass
+          else
+            command.subcommand name, "#{desc} (#{self})", &block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mystro/userdata.rb

@@ -0,0 +1,42 @@
+require 'erubis'
+
+module Mystro
+  class Userdata
+    class << self
+      def create(name, roles, environment, opts={ })
+        package      = opts.delete(:package)
+        dependencies = opts.delete(:dependencies)
+        gems         = opts.delete(:gems)
+        files        = opts.delete(:files)
+        directory    = "#{Mystro.directory}/userdata/#{package}"
+        file         = "#{directory}/userdata.yml"
+        raise "userdata error: package not specified" unless package
+        raise "userdata error: pacakge #{package} directory does not exist (#{directory})" unless File.directory?(directory)
+        raise "userdata error: configuration file does not exist (#{file})" unless File.exists?(file)
+        config = YAML.load_file(file)
+
+        data = {
+            :name         => name,
+            :roles        => roles,
+            :environment  => environment,
+            :nickname     => name,
+            :account      => "unknown",
+            :zone         => "unknown.local",
+            :dependencies => [],
+            :gems         => [],
+            :files        => [],
+            :directory    => directory,
+            :template     => "userdata.sh.erb",
+        }.deep_merge(config.symbolize_keys!).deep_merge(opts.symbolize_keys!)
+
+        data[:gems] += gems if gems
+        data[:dependencies] += dependencies if dependencies
+        data[:files] += files if files
+
+        template = File.open("#{directory}/#{data[:template]}").read
+        erb      = Erubis::Eruby.new(template)
+        out      = erb.evaluate(data)
+      end
+    end
+  end
+end