mystro-common 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mystro-common.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Shawn Catanzarite
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Mystro::Common
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mystro-common'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mystro-common
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,51 @@
+require "bundler/gem_tasks"
+
+def changelog(last=nil, single=false)
+  command="git --no-pager log --format='%an::::%h::::%s'"
+
+  list = `git tag`
+
+  puts "# Changelog"
+  puts
+
+  ordered = list.lines.sort_by {|e| (a,b,c) = e.gsub(/^v/,"").split("."); "%3d%3d%3d" % [a, b, c]}
+
+  ordered.reject{|e| (a,b,c,d) = e.split("."); !d.nil?}.reverse_each do |t|
+    tag = t.chomp
+
+    if last
+      check = { }
+      out   = []
+      log   = `#{command} #{last}...#{tag}`
+      log.lines.each do |line|
+        (who, hash, msg) = line.split('::::')
+        unless check[msg]
+          unless msg =~ /^Merge branch/ || msg =~ /CHANGELOG/ || msg =~ /^(v|version|changes for|preparing|ready for release|ready to release|bump version)*\s*(v|version)*\d+\.\d+\.\d+/
+            msg.gsub(" *", "\n*").gsub(/^\*\*/, "  *").lines.each do |l|
+              line = l =~ /^(\s+)*\*/ ? l : "* #{l}"
+              out << line
+            end
+            check[msg] = hash
+          end
+        end
+      end
+      puts "## #{last}:"
+      out.each { |e| puts e }
+      #puts log
+      puts
+    end
+
+    last = tag
+    exit if single
+  end
+end
+
+desc "generate changelog output"
+task :changelog do
+  changelog
+end
+
+desc "show current changes (changelog output from HEAD to most recent tag)"
+task :current do
+  changelog("HEAD",true)
+end

data/lib/mystro/account.rb

@@ -0,0 +1,97 @@
+module Mystro
+  class Account
+    class << self
+      #attr_reader :name
+      attr_reader :list
+      attr_reader :selected
+
+      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/capistrano.rb

@@ -0,0 +1,50 @@
+## integration with capistrano
+## have some helpers to use mystro to get the
+## host lists for capistrano to use.
+#
+#require 'mystro'
+#require 'mystro/model'
+#require 'capistrano'
+#
+#module Mystro
+#  module Capistrano
+#    def servers
+#      env     = Mystro.config[:environment]
+#      role    = Mystro.config[:role]
+#      servers = Mystro::Model::Environment.find(env).servers
+#      list    = role == 'all' ? servers : servers.select { |s| (s.tags['Roles']||"").split(",").include?(role) }
+#
+#      raise "Mystro could not find any servers matching environment=#{env} and role=#{role}" unless list && list.count > 0
+#      list.each do |s|
+#        server "#{s.tags['Name']}.#{Mystro.get_config(:dns_zone)}", :web, :app
+#      end
+#    rescue => e
+#      puts "*** servers not found: #{e.message}"
+#    end
+#  end
+#end
+#
+#::Capistrano.plugin :mystro, Mystro::Capistrano
+#
+#configuration = Capistrano::Configuration.respond_to?(:instance) ?
+#    Capistrano::Configuration.instance(:must_exist) :
+#    Capistrano.configuration(:must_exist)
+#
+#configuration.load do
+#  puts "  * reading mystro information..."
+#
+#  Mystro.config[:environment] = ENV['ENVIRONMENT'] || ARGV[0]
+#  Mystro.config[:role]        = ENV['ROLE'] || ARGV[1]
+#
+#  # create dummy tasks for environment and role
+#  begin
+#    ARGV.first(2).each do |arg|
+#      task arg do
+#        nil
+#      end
+#    end
+#  rescue
+#    nil
+#  end
+#
+#end

data/lib/mystro/common/version.rb

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

data/lib/mystro/config.rb

@@ -0,0 +1,29 @@
+module Mystro
+  class Config
+    class << self
+      def instance
+        @instance ||= self.new
+      end
+    end
+
+    attr_reader :data
+
+    def initialize
+      f = "#{Mystro.directory}/config.yml"
+      d = File.exists?(f) ? YAML.load_file(f) : {}
+      c = Hashie::Mash.new(d)
+
+      if c.logging?
+        c.logging.each do |level, dest|
+          Mystro::Log.add(level.to_sym, dest)
+        end
+      end
+
+      Mystro::Log.debug "loading plugins from configuration"
+      Mystro::Plugin.load(c[:plugins]) if c[:plugins]
+      @raw = c
+      @data = Hashie::Mash.new(c)
+      @data.directory = Mystro.directory
+    end
+  end
+end

data/lib/mystro/connect/balancer.rb

@@ -0,0 +1,91 @@
+
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,38 @@
+
+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
+
+      # customize the connect function, because we are defaulting
+      # to the zone from the configuration
+      def connect
+        @fog ||= begin
+          raise "could not connect to DNS; #{opt.to_hash.inspect}; #{cfg.to_hash.inspect}" unless opt && cfg.zone
+          dns = Fog::DNS.new(opt)
+          dns.zones.find(cfg.zone).first
+        end
+      rescue => e
+        Mystro::Log.error "DNS connect failed: #{e.message} at #{e.backtrace.first}"
+        Mystro::Log.error e
+      end
+
+      def zones
+        Fog::DNS.new(opt).zones.all
+      end
+
+      def zone(name)
+        Fog::DNS.new(opt).zones.find(name).first
+      end
+
+      def create_zone(model)
+        Fog::DNS.new(opt).zones.create(model.fog_options)
+      end
+    end
+  end
+end

data/lib/mystro/connect/environment.rb

@@ -0,0 +1,31 @@
+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