mystro-common 0.1.11 → 0.2.0

data/lib/mystro/account.rb

@@ -1,105 +0,0 @@
-module Mystro
-  class Account
-    class << self
-      #attr_reader :name
-      #attr_reader :list
-      attr_reader :selected
-
-      def [](name)
-        get(name)
-      end
-
-      def get(name)
-        @list[name]
-      end
-
-      def read
-        dir   = Mystro.directory
-        @list = { }
-
-        Dir["#{dir}/accounts/*.y*ml"].each do |file|
-          name = file.gsub(/#{dir}\/accounts\//, "").gsub(/\.(\w+?)$/, "")
-          Mystro::Log.debug "loading account '#{name}' '#{file}'"
-          @list[name] = self.new(name, file)
-        end
-
-        @selected = default
-      end
-
-      def default
-        return ENV['MYSTRO_ACCOUNT'] if ENV['MYSTRO_ACCOUNT']
-        return Mystro.config.default_account if Mystro.config.default_account?
-        return "default" if @list.keys.include?("default")
-        @list.keys.first
-      end
-
-      def select(name)
-        @selected = name
-      end
-
-      #def data(name = get)
-      #  if @name != name
-      #    @data = nil
-      #    @loaded = false
-      #    @name = nil
-      #  end
-      #
-      #  @data ||= begin
-      #    Mystro::Log.debug "loading account"
-      #    a        = Mystro::Model::Account.load(name)
-      #    a[:name] = name
-      #
-      #    Mystro::Log.debug "loading plugins from account"
-      #    Mystro::Plugin.load(a[:plugins]) if a[:plugins]
-      #
-      #    a
-      #  end
-      #  @name = @data[:name]
-      #  @loaded = true
-      #  @data
-      #end
-      #
-      #def get
-      #  return ENV['RIG_ACCOUNT'] if ENV['RIG_ACCOUNT']
-      #  return Mystro.config[:account] if Mystro.config[:account]
-      #  return Mystro.config[:default_account] if Mystro.config[:default_account]
-      #  return Mystro.config[:accounts].first if Mystro.config[:accounts] && Mystro.config[:accounts].count > 0
-      #  "default"
-      #end
-      #
-      #def save
-      #  name = Mystro.account[:name]
-      #  Mystro::Model::Account.save(name, Mystro.account)
-      #end
-    end
-
-    attr_reader :data
-    attr_reader :file
-    attr_reader :name
-
-    def initialize(name, file)
-      cfg     = Mystro.config.to_hash
-      account = File.exists?(file) ? YAML.load_file(file) : { }
-      @name   = name
-      @file   = file
-      @data   = Hashie::Mash.new(cfg.deep_merge(account))
-      @data.name = name
-    end
-
-    def compute
-      @compute ||= Mystro::Connect::Compute.new(self) if @data.compute
-    end
-
-    def balancer
-      @balancer ||= Mystro::Connect::Balancer.new(self) if @data.balancer
-    end
-
-    def dns
-      @dns ||= Mystro::Connect::Dns.new(self) if @data.dns
-    end
-
-    def environment
-      @environment ||= Mystro::Connect::Environment.new(self)
-    end
-  end
-end

data/lib/mystro/connect/balancer.rb

@@ -1,91 +0,0 @@
-
-module Mystro
-  module Connect
-    class Balancer < Base
-      self.model      = "Fog::Balancer"
-      self.collection = :load_balancers
-
-      def all
-        fog.send(collection).all
-      end
-
-      def create(model)
-        balancer = fog.send(collection).create(model.fog_options)
-        balancer.register_instances(model.computes.collect{|e| e.rid})
-        balancer.save
-      end
-
-      def find_by_environment(name)
-        all.select {|e| e.id =~ /^#{name}\-/}
-      end
-
-      def listener_find(id, from)
-        balancer = find(id)
-        (from_proto, from_port) = from.split(':')
-        match = balancer.listeners.select {|l| l.protocol == from_proto && l.lb_port == from_port.to_i }
-        raise "no listeners #{from} found" if match.count == 0
-        raise "more than one listener matched #{from}" if match.count > 1
-        match.first
-      end
-
-      def listener_create(id, model)
-        Mystro::Log.debug "balancer#add_listener #{id} #{model.inspect}"
-        lb = find(id)
-        opts = model.fog_options
-        ap opts
-        lb.listeners.create(opts)
-      end
-
-      def listener_destroy(id, from)
-        Mystro::Log.debug "balancer#rm_listener #{id} #{from}"
-        listener = listener_find(id, from)
-        listener.destroy
-      end
-
-      def health_check(id, health)
-        Mystro::Log.debug "balancer#health_check #{id} #{health.inspect}"
-        balancer = find(id)
-        raise "balancer #{id} not found" unless balancer
-
-        fog.configure_health_check(id, health.fog_options)
-      end
-
-      def sticky(id, type, expires_or_cookie, port, policy=nil)
-        balancer = find(id)
-        raise "balancer #{id} not found" unless balancer
-
-        policy ||= "sticky-#{id}-#{type}-#{port}"
-        policies = balancer.attributes["ListenerDescriptions"] ? balancer.attributes["ListenerDescriptions"].inject([]) {|a, e| a << e["PolicyNames"]}.flatten : []
-        policies << policy
-
-        case type.downcase.to_sym
-          when :app, :application
-            fog.create_app_cookie_stickiness_policy(id, policy, expires_or_cookie)
-            fog.set_load_balancer_policies_of_listener(id, port.to_i, policies)
-          when :lb, :loadbalancer, :load_balancer
-            fog.create_lb_cookie_stickiness_policy(id, policy, expires_or_cookie.to_i)
-            fog.set_load_balancer_policies_of_listener(id, port.to_i, policies)
-          else
-            raise "unknown sticky type #{type}"
-        end
-      end
-
-      def unsticky(id, type, port, policy=nil)
-        balancer = find(id)
-        raise "balancer #{id} not found" unless balancer
-
-        policy ||= "sticky-#{id}-#{type}-#{port}"
-        policies = balancer.attributes["ListenerDescriptions"] ? balancer.attributes["ListenerDescriptions"].inject([]) {|a, e| a << e["PolicyNames"]}.flatten : []
-        policies.delete(policy)
-
-        case type.downcase.to_sym
-          when :app, :application, :lb, :loadbalancer, :load_balancer
-            fog.set_load_balancer_policies_of_listener(id, port.to_i, policies)
-            fog.delete_load_balancer_policy(id, policy)
-          else
-            raise "unknown sticky type #{type}"
-        end
-      end
-    end
-  end
-end

data/lib/mystro/connect/compute.rb

@@ -1,100 +0,0 @@
-module Mystro
-  module Connect
-    class Compute < Base
-      self.model      = "Fog::Compute"
-      self.collection = :servers
-
-      def all(filters={ })
-        fog.send(collection).all(filters)
-      end
-
-      def running
-        all({ "instance-state-name" => "running" })
-      end
-
-      def find(id_or_name)
-        if id_or_name =~ /^i-/
-          super(id_or_name)
-        else
-          find_by_name(id_or_name)
-        end
-      end
-
-      def find_by_name(name)
-        list = find_by_tags(name: name)
-        return list if list.count > 0
-        find_by_nick(name)
-      end
-
-      def find_by_nick(nick)
-        Mystro::Log.debug "compute#find_by_nick #{nick}"
-        (name, env) = nick.match(/(\w+)\.(\w+)/)[1..2]
-        find_by_environment(env).select { |s| s.tags['Name'] =~ /^#{name}/ }
-      rescue => e
-        Mystro::Log.error "error finding server by nickname #{nick}. name should be of the form: role#.environment"
-        []
-      end
-
-      def find_by_environment(environment)
-        find_by_tags(environment: environment)
-      end
-
-      def find_by_environment_and_role(environment, role)
-        list = find_by_tags(environment: environment)
-        list.select { |s| r = s.tags['Roles'] || s.tags['Role']; r.split(",").include?(role) }
-      end
-
-      def find_by_tags(tags)
-        Mystro::Log.debug "compute#find_by_tags #{tags.inspect}"
-        filters = tags.inject({ }) { |h, e| (k, v) = e; h["tag:#{k.to_s.capitalize}"] = v; h }
-        all(filters)
-      end
-
-      def create(model)
-        Mystro::Log.debug "#{cname}#create #{model.inspect}"
-        e = fog.send(collection).create(model.fog_options)
-        fog.create_tags(e.id, model.fog_tags)
-        Mystro::Plugin.run "compute:create", e, model
-        e
-      end
-
-      #after :create do |compute, model|
-      #  Mystro::Log.debug "compute#after_create #{compute.id} #{model.fog_tags}"
-      #  Mystro::Log.debug "#{cname}#create #{fog.inspect}"
-      #  sleep 3
-      #end
-
-      def destroy(models)
-        list = [*models].flatten
-        list.each do |m|
-          Mystro::Log.debug "#{cname}#destroy #{m.rid}"
-          e = find(m.rid)
-          Mystro::Plugin.run "compute:destroy", e, m
-          e.destroy
-          tags = e.tags.keys.inject({ }) { |h, e| h[e] = nil; h }
-          fog.create_tags([e.id], tags)
-        end
-      end
-
-      #def destroy(list)
-      #  list = [*list]
-      #  if list.count > 0
-      #    ids = list.map {|e| e.kind_of?(String) ? e : e.id}
-      #    Mystro::Log.debug "compute#destroy: #{ids.inspect}"
-      #    list.each do |e|
-      #      Mystro::Plugin.run "compute:destroy", e
-      #      e.destroy
-      #      tags = e.tags.keys.inject({}) {|h, e| h[e] = nil; h }
-      #      fog.create_tags(ids, tags)
-      #    end
-      #  end
-      #end
-
-      #after :destroy do |compute, tags|
-      #  Mystro::Log.debug "#{cname}#after_destroy"
-      #  tags = compute.tags.keys.inject({ }) { |h, e| h[e] = nil; h }
-      #  fog.create_tags([compute.id], tags) if tags.count > 0
-      #end
-    end
-  end
-end

data/lib/mystro/connect/dns.rb

@@ -1,51 +0,0 @@
-
-module Mystro
-  module Connect
-    class Dns < Base
-      self.model      = "Fog::DNS"
-      self.collection = :records
-
-      def find_by_endpoint(dns)
-        all.select {|e| [*e.value].flatten.include?(dns)}
-      end
-
-      def find_by_name(name)
-        connection.zones.all.detect {|e| e.domain == "#{name}."}
-      end
-
-      # customize the connect function, because we are defaulting
-      # to the zone from the configuration
-      def connect
-        @fog ||= begin
-          raise "must set zone" unless cfg.zone
-          raise "must set options" unless opt
-          find_by_name(cfg.zone)
-        end
-      rescue => e
-        Mystro::Log.error "DNS connect failed: #{e.message} at #{e.backtrace.first}"
-        Mystro::Log.error e
-      end
-
-      def connection
-        Fog::DNS.new(opt.to_hash.symbolize_keys)
-      end
-
-      def zones
-        connection.zones.all
-      end
-
-      def zone(name)
-        n = "#{name}."
-        z = connection.zones.get(n)
-        raise("zone #{n} not found") unless z
-        z
-      rescue => e
-        raise("#{e.message} at #{e.backtrace.first}")
-      end
-
-      def create_zone(model)
-        connection.zones.create(model.fog_options)
-      end
-    end
-  end
-end

data/lib/mystro/connect/environment.rb

@@ -1,31 +0,0 @@
-module Mystro
-  module Connect
-    class Environment < Base
-      def connect
-
-      end
-
-      def connected?
-        true
-      end
-
-      def find(name)
-        Mystro::Model::Environment.load(name)
-      end
-
-      def all
-        list = Mystro.compute.all
-        list.inject([]) { |a, e| a << e.tags["Environment"] }.compact.uniq.sort
-      end
-
-      def create(model)
-        Mystro::Log.info "model: #{model}"
-        list = model.template_to_models
-      end
-
-      def destroy
-
-      end
-    end
-  end
-end

data/lib/mystro/connect.rb

@@ -1,124 +0,0 @@
-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
-        #puts "connect: #{model}.new(#{opt.to_hash.symbolize_keys})"
-        @fog ||= model.new(opt.to_hash.symbolize_keys) 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/model.rb

@@ -1,71 +0,0 @@
-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/, '') }