mystro-common 0.1.11 → 0.2.0

data/lib/mystro/cloud/model.rb

@@ -0,0 +1,183 @@
+require 'mystro/log'
+
+module Mystro
+  module Cloud
+    class Model
+      attr_reader :data
+
+      def initialize(hash={})
+        @data = {}
+        load(hash)
+      end
+
+      def load(hash)
+        #puts "LOAD: #{hash.inspect}"
+        if hash.is_a?(Hash)
+          hash.each do |k, v|
+            k = normal_key(k)
+            k = alias_for(k) || k
+            attr = attribute_for(k)
+            #puts "attr: #{k}: #{attr.inspect}"
+            raise "#{self.class.name}: attr not found for #{k.inspect}" unless attr
+            if attr[:child]
+              if attr[:type] == Array
+                next unless v# && v.count
+                v = [v] unless v.is_a?(Array)
+                @data[k] ||= []
+                v.each do |e|
+                  if e.is_a?(Mystro::Cloud::Model)
+                    @data[k] << e
+                  else
+                    c = class_for(attr[:of])
+                    @data[k] << c.new(e)
+                  end
+                end
+              else
+                c = class_for(attr[:type])
+                if v.class == c
+                  @data[k] = v
+                else
+                  @data[k] = c.new(v)
+                end
+              end
+            elsif attr[:type] == :boolean
+              @data[k] = v && (v == true || v == "true")
+            else
+              @data[k] = v
+            end
+          end
+        else
+          hash
+        end
+      end
+
+      def validate!
+        self.class.validate!(@data)
+      end
+
+      def attribute_for(name)
+        self.class.attribute_for(name)
+      end
+
+      def alias_for(name)
+        self.class.alias_for(name)
+      end
+
+      def normal_key(k)
+        self.class.normal_key(k)
+      end
+
+      def class_for(name)
+        self.class.class_for(name)
+      end
+
+      def [](key)
+        send(key.to_sym)
+      end
+      def []=(key, value)
+        send("#{key}=", value)
+      end
+
+      def to_hash
+        out = {}
+        #puts "#{self.class.name}: to_hash:"
+        @data.each do |k, v|
+          #puts "  #{k} => #{v}"
+          if v.respond_to?(:to_hash)
+            out[k] = v.to_hash
+          elsif v.is_a?(Array)
+            out[k] = v.map {|e| e.respond_to?(:to_hash) ? e.to_hash : e}
+          else
+            out[k] = v
+          end
+        end
+        out
+      end
+
+      class << self
+
+        def validate!(data)
+          @attributes.each do |k, v|
+            type = v[:type]
+            type = type.is_a?(String) ? class_for(type) : type
+            value = data[k]
+            value = value.to_s if value.is_a?(Symbol)
+            #puts "checking: #{k}#{'*' if v[:required]} (#{type})"
+            raise "#{k} required but is nil or false" if v[:required] && !value
+            raise "#{k} required but empty" if v[:required] && type == Array && value.empty?
+            raise "incorrect type: #{k}: '#{value.inspect}' is not a '#{type}'" if value && !value.is_a?(type)
+          end
+        rescue => e
+          raise "#{e.message}: #{data.inspect}"
+        end
+
+        def attribute_for(name)
+          @attributes[name] || @attributes[name] || @aliases[name] && @attributes[@aliases[name]]
+        end
+
+        def alias_for(name)
+          @aliases[name]
+        end
+
+        def class_for(name)
+          n = name.to_s.capitalize
+          begin
+            return "Mystro::Cloud::#{n}".constantize
+          rescue => e
+            begin
+              return n.constantize
+            rescue => e
+              raise "couldn't find class: #{n}: #{e.message}"
+            end
+          end
+        end
+
+        def normal_key(k)
+          k.to_s.downcase.to_sym
+        end
+
+        protected
+
+        def identity(name, options={})
+          attribute(name, options.merge(identity: true))
+        end
+
+        def attribute(name, options={})
+          @attributes ||= {}
+          @aliases ||= {}
+          name = normal_key(name)
+          o = {name: name, type: String, required: true, aliases: []}.merge(options)
+          @attributes[name.to_sym] = o
+          list = [name] + o[:aliases]
+          list += [:identity] if o[:identity]
+          list.each do |m|
+            define_method(m) do
+              @data[name.to_sym]
+            end
+            define_method("#{m}=") do |value|
+              h = {}
+              h[name.to_sym] = value
+              load(h)
+            end
+          end
+          o[:aliases].each do |a|
+            @aliases[normal_key(a)] = name
+          end
+        end
+
+        def has_one(name, options={})
+          attribute(name, {type: options.delete(:type), child: true}.merge(options))
+        end
+
+        def has_many(name, options={})
+          attribute(name, {type: Array, of: options.delete(:type), child: true}.merge(options))
+        end
+      end
+    end
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/model/*.rb"].each do |file|
+  #puts "require: #{file}"
+  require "#{file.gsub(/\.rb/, '')}"
+end

data/lib/mystro/cloud.rb

@@ -0,0 +1,32 @@
+module Mystro
+  module Cloud
+    class << self
+      def new(provider, type, options={})
+        Mystro::Log.debug "Mystro::Cloud.new #{provider.inspect} #{type.inspect} #{options.inspect}"
+        d = {
+            options: {},
+            config: {},
+        }.merge(options)
+        type = type.to_sym
+        d[:options] ||= {}
+        d[:config] ||= {}
+        o = d[:options].merge(Mystro::Provider.get(provider).to_hash)
+        c = d[:config]
+        klass = class_for(provider, type)
+        klass.new(o, c)
+      end
+
+      def class_for(provider, type)
+        n = provider.to_s.capitalize
+        t = type.to_s.capitalize
+        c = "Mystro::Cloud::#{n}::#{t}"
+        c.constantize
+      end
+    end
+    class NotFound < StandardError; end
+  end
+end
+
+require 'mystro/cloud/model'
+require 'mystro/cloud/connect'
+require 'mystro/cloud/action'

data/lib/mystro/common/version.rb

@@ -2,10 +2,11 @@ module Mystro
   module Common
     module Version
       MAJOR = 0
-      MINOR = 1
-      TINY  = 11
+      MINOR = 2
+      TINY  = 0
       TAG   = nil
-      STRING = [MAJOR, MINOR, TINY, TAG].compact.join(".")
+      LIST  = [MAJOR, MINOR, TINY, TAG]
+      STRING = LIST.compact.join(".")
     end
   end
 end

data/lib/mystro/dsl/balancer.rb

@@ -0,0 +1,18 @@
+class Mystro::Dsl::Balancer < Mystro::Dsl::Base
+  attribute :name
+  attribute :primary, type: :boolean, value: false
+  has_one :health
+  has_many :listeners
+
+  def actions
+    hash = to_hash
+    action = Mystro::Cloud::Action.new('Mystro::Cloud::Balancer', :create)
+    action.data = {
+        name: hash[:name],
+        primary: hash[:primary],
+        health: hash[:health],
+        listeners: hash[:listener],
+    }
+    [action]
+  end
+end

data/lib/mystro/dsl/compute.rb

@@ -0,0 +1,57 @@
+class Mystro::Dsl::Compute < Mystro::Dsl::Base
+  attribute :num, value: 0 do |value|
+    value == value.to_i
+  end
+  attribute :name
+  attribute :image
+  attribute :flavor
+  attribute :keypair
+  attribute :userdata
+  attribute :group, type: Array
+  attribute :role, type: Array
+  has_many :volumes
+  has_many :records
+  references :balancer
+
+  def actions
+    c = to_hash
+    n = c[:num].to_i
+    out = []
+    if n > 0
+      1.upto(n) do |i|
+        out << create_action(i, c)
+      end
+    else
+      out << create_action(nil, c)
+    end
+    out
+  end
+
+  private
+
+  def create_action(i, c)
+    num = i ? "%02d" % i : ''
+    name = "#{c[:name]}#{num}"
+    roles = (c[:role]||[]).join(',')
+    action = Mystro::Cloud::Action.new('Mystro::Cloud::Compute', :create)
+    action.options = {
+        balancer: c[:balancer],
+        records: c[:record],
+    }
+    data = {
+        image: c[:image],
+        flavor: c[:flavor],
+        keypair: c[:keypair],
+        userdata: c[:userdata],
+        groups: c[:group],
+        tags: {'Roles' => roles, 'Name' => name},
+    }.delete_if {|k, v| v.nil?}
+    if c[:volume]
+      data[:volumes] = c[:volume].map do |vol|
+        Mystro::Cloud::Volume.new(vol)
+      end
+    end
+    action.data = data
+    action
+  end
+end

data/lib/mystro/dsl/health.rb

@@ -0,0 +1,7 @@
+class Mystro::Dsl::Health < Mystro::Dsl::Base
+  attribute :healthy, value: 10
+  attribute :unhealthy, value: 2
+  attribute :interval, value: 5
+  attribute :target, value: 'HTTP:80/'
+  attribute :time, value: 30   #TODO: timeout doesn't work, doesn't override Timeout#timeout
+end

data/lib/mystro/dsl/listener.rb

@@ -0,0 +1,5 @@
+class Mystro::Dsl::Listener < Mystro::Dsl::Base
+  attribute :from, value: 'HTTP:80'
+  attribute :to, value: 'HTTP:80'
+  attribute :cert
+end

data/lib/mystro/dsl/oldtemplate.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