blend 0.1.4

data/lib/blend/core_ext/fixnum.rb

@@ -0,0 +1,5 @@
+class Fixnum
+  def projectize
+    self.to_s.gsub(/\s/,'').downcase
+  end
+end

data/lib/blend/core_ext/object.rb

@@ -0,0 +1,13 @@
+class Object
+
+  # Coped from activesupport because it's useful but doesn't justify pulling in
+  # activesupport dependencies:
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      __send__(*a, &b)
+    end
+  end
+
+end

data/lib/blend/core_ext/string.rb

@@ -0,0 +1,9 @@
+class String
+  def projectize
+    gsub(/\s/,'').downcase
+  end
+
+  def strip_email
+    gsub(/\s*<[^>]*>\s*/,'')
+  end
+end

data/lib/blend/exceptions.rb

@@ -0,0 +1,16 @@
+module Blend
+  module Exceptions
+    class AuthenticationFailure < StandardError; end
+    class LoginAuthenticationFailure < StandardError; end
+    class AlreadyLoggedIn < StandardError; end
+    class AlreadyLoggedOut < StandardError; end
+    class HipchatAuthenticationFailure < StandardError; end
+
+    class << self
+      def formatted(e)
+        puts "#{e.backtrace.shift}: #{e.message}"
+        puts e.backtrace.first(10).map{|x| "\t"+x}.join("\n")
+      end
+    end
+  end
+end

data/lib/blend/status/domain.rb

@@ -0,0 +1,225 @@
+require 'dnsruby'
+require 'whois'
+require 'httpclient'
+
+module Blend
+  module Status
+    class Domain
+      attr_accessor :project, :domain, :res, :environment
+
+      def initialize( project, environment, domain )
+        @project = project
+        @environment = environment
+        @domain = domain
+        @res = Dnsruby::Resolver.new
+      end
+
+
+      class << self
+        def check(domain)
+          dc = self.new(domain)
+
+          result = {}
+          begin
+
+            result[:registered] = dc.registered?
+            result[:registrar] = dc.registrar
+            result[:ssl] = dc.ssl
+            result[:expires] = dc.expires
+            result[:owner] = dc.owner
+            result[:name_servers] = dc.name_servers
+            result[:dns] = {
+              ns: dc.ns,
+              mx: dc.mx,
+              cname: dc.cname,
+              a: dc.a
+            }
+
+          rescue Dnsruby::ServFail => e
+            result[:error] = "DomainChecker encountered #{e.to_s}: You might just need to retry this."
+          end
+
+          result
+        end
+      end
+      
+
+      ## Find out meta data
+
+      def registered?
+        whois.registered?
+      end
+
+      def registrar
+        whois.registrar
+      end
+
+      def owner
+        whois.registrant_contacts
+      end
+
+      def expires
+        whois.expires_on
+      end
+
+      def inbound_mailers
+        get_data(mx).sort { |a,b| a[0] <=> b[0]}
+      end
+
+      def name_servers
+        get_data(ns)
+      end
+
+      def ssl
+        if @ssl.nil?
+          c = HTTPClient.new
+          c.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          p = c.get( "https://#{domain}")
+          @ssl = p.peer_cert
+        end
+        return nil if( ssl_common_name.nil? )
+        @ssl
+      end
+
+      def ssl_exists?
+        !ssl.nil?
+      end
+
+      def ssl_valid_until
+        return nil if ssl.nil?
+        ssl.not_after
+      end
+
+      def ssl_common_name
+        ssl if @ssl.nil?
+        return nil if @ssl.nil?
+        ret = (@ssl.subject.to_a.select { |x| x[0] == 'CN' }.first || [])[1]
+        return nil if ( ret =~ /herokuapp/ )
+        ret
+      end
+
+      ## Details
+
+      def lookup( type )
+        @results ||= {}
+        if @results[type].nil?
+          @results[type] = parse_answer( type )
+          if type == "A" || type == "CNAME"
+            @results[type] = parse_answer type, @results[type][:domains]
+          end
+        end
+
+        # @results[type]
+        #   @results = { domain: @domain }
+        #   @results[:ns] = parse_answer( "NS" )
+        #   @results[:a] = parse_answer( "A" )
+        #   @results[:a] = parse_answer( "A", @results[:a][:domains] )
+        #   @results[:cname] = parse_answer( "CNAME" )
+        #   @results[:cname] = parse_answer( "CNAME", @results[:cname][:domains] )
+        #   @results[:mx] = parse_answer( "MX" )
+        # end
+        @results[type]
+      end
+      
+      def ns
+        lookup "NS"
+      end
+      
+      def a
+        lookup "A"
+      end
+      
+      def mx
+        lookup "MX"
+      end
+      
+      def cname
+        lookup "CNAME"
+      end
+      
+      def whois
+        @whois ||= Whois.lookup @domain
+      end
+
+      def parse_answer( type, domains = false )
+        domain = @domain
+        domain = "www.#{@domain}" if domains
+        ret = {domains: []}
+        ret = {domains: domains} if domains
+        begin
+          rr = @res.query( domain, type)
+          # puts rr.answer
+          rr.answer.each do |answer|
+            ret[:domains] << { domain: domain, name:answer.name.to_s, ttl: answer.ttl, data: answer.rdata, type: answer.type } if answer.type == type
+          end
+        rescue Dnsruby::ResolvTimeout
+          ret[:error] = :timeout
+        rescue Dnsruby::NXDomain
+          ret[:error] = :notfound
+        end
+        
+        ret
+      end
+
+      def get_data array
+        array[:domains].collect{ |x| x[:data] }
+      end
+      
+      # def registrar
+      #   last_2_records ns
+      # end
+      
+      # def mailer
+      #   records( mx ).collect { |x| x[1].labels[-2..-1].collect { |x| x.to_s.downcase }.join( "." ) }.uniq.select { |x| x != "google.com"}
+      # end
+      
+      # def last_2_records a
+      #   records( a ).collect { |x| x.labels[-2..-1].collect { |x| x.to_s }.join( "." ) }.uniq
+      # end
+      
+      # def records v
+      #   if v[:domains]
+      #     v[:domains].collect { |x| x[:data] }
+      #   else
+      #     []
+      #   end
+      # end
+      
+      def heroku?
+        a_ips = a[:domains].select { |x| x[:domain] == @domain }.collect { |x| x[:data].to_s }.sort
+        # puts a_ips
+        return true if a_ips == ["174.129.212.2", "75.101.145.87", "75.101.163.44"] 
+        
+
+        # puts cname[:domains].to_s 
+        # return false if cname[:domains].first[:data].to_s != "proxy.heroku.com"
+        
+        return true
+      end
+
+      def check key, method
+        ret = __send__( method )
+        ret = false if ret.nil?
+        ret = false if ret == []
+        ret = ret.collect { |x| x[:name] || x['name'] }.join( "," ) if ret.is_a? Array
+
+        pass = ret
+
+        if( ret.is_a? Integer )
+          if( method == :dyno_redundancy)
+            pass = ret > 1
+            ret = "#{ret} dynos"
+          end
+        end
+
+        printf "%20s: ", key
+        if( pass )
+          printf "\u2713 #{ret}\n".encode('utf-8').green
+        else
+          printf "\u2718 #{ret}\n".encode('utf-8').red
+        end
+      end
+
+    end
+  end
+end

data/lib/blend/status/environment.rb

@@ -0,0 +1,167 @@
+module Blend
+  module Status
+    class Environment
+      attr_accessor :project, :server, :environment
+
+      def initialize( project, server, environment )
+        @project = project
+        @server = server
+        @environment = environment
+      end
+
+      def check key, method
+        ret = __send__( method )
+        ret = false if ret.nil?
+        ret = false if ret == []
+        ret = ret.collect do |x|
+          if( x.is_a? Hash )
+            x[:name] || x['name']
+          else
+            x
+          end
+        end.join( "," ) if ret.is_a? Array
+
+        pass = ret
+
+        if( ret.is_a? Integer )
+          if( method == :dyno_redundancy)
+            pass = ret > 1
+            ret = "#{ret} dynos"
+          end
+        end
+
+        printf "%20s: ", key
+        if( pass )
+          printf "\u2713 #{ret}\n".encode('utf-8').green
+        else
+          printf "\u2718 #{ret}\n".encode('utf-8').red
+          if( @project.resolve )
+            r = "resolve_#{method}".to_sym
+            __send__(r) if respond_to? r
+          end
+
+        end
+      end
+
+      def client
+        Blend::Client.heroku_client
+      end
+
+      def log_monitoring
+        client.addons(@server, /(logentries|keen|papertrail|loggly|flydata)/)
+      end
+
+      def app_monitoring
+        client.addons(@server, /(relic)/)
+      end
+
+      def exception_handling
+        client.addons(@server, /(airbrake|exceptional)/)
+      end
+
+      def deployhooks
+        client.addons(@server, /deployhooks/)
+      end
+
+      def resolve_deployhooks
+        system( "echo heroku addons:add deployhooks:hipchat --auth_token=#{@project.juice_client.hipchat_api} --room=\"#{@project.config['hipchat_room']}\" --app #{@server}")
+        system( "heroku addons:add deployhooks:hipchat --auth_token=#{@project.juice_client.hipchat_api} --room=\"#{@project.config['hipchat_room']}\" --app #{@server}" )
+        Blend::Client::hipchat_client.post_message @project.config['hipchat_room'], "Heroku app: #{@server} commit hook now added"
+
+      end
+
+      def ssl
+        client.addons(@server, /ssl/)
+      end
+
+      def backups
+        client.backups(@server).collect { |x| x[:plan] }
+      end
+
+      def database
+        client.databases(@server).collect { |x| x[:plan] }
+      end
+
+      def dyno_redundancy
+        client.dynos(@server).to_i
+      end
+
+      def stack
+        client.stack( @server ) == 'cedar'
+      end
+
+      def domains
+        client.nonheroku_domains( @server )
+      end
+    end
+  end
+end
+__END__
+
+
+
+
+
+      desc 'check_domains [APP]', 'Check domains'
+      def check_domains(app)
+        client.nonheroku_domains(app).each do |domain|
+          puts "\nChecking domain #{domain}:".blue
+          result = DomainChecker.check(domain)
+
+          if result.include? :error
+            puts result[:error].red
+            return
+          end
+          
+          # Check registration
+          if result[:registered]
+            r = result[:registrar]
+
+            # Registrar:
+            if r.nil?
+              printf "%25s: %s", 'Registrar', format_result(:warn, "DNS not configured correctly for #{domain}")
+            else
+              registrar = [r['name'], r['organization'], r['url']].reject(&:nil?).join(';  ')
+              printf "%25s: %s", 'Registrar', format_result(:pass, registrar)
+            end
+          else
+            printf "%25s: %s", 'Registrar', format_result(:fail)
+          end
+
+
+          unless result[:expires].nil?
+            # Expiration:
+            days_to_expiration = ((result[:expires] - Time.now)/(3600.0*24.0)).to_i 
+            formatted_dte = "#{result[:expires].strftime("%F")} (#{days_to_expiration} days from now)"
+            if days_to_expiration < 30
+              state = :fail
+            elsif days_to_expiration < 30*3
+              state = :warn
+            else
+              state = :pass
+            end
+
+            printf "%25s: %s", 'Expiration date', format_result(state, formatted_dte)
+          end
+
+          printf "%25s:\n", 'DNS'
+          result[:dns].each do |k,v|
+            v[:domains].each do |record|
+              if record[:type] == 'MX'
+                description = "#{record[:data][0]}: #{record[:data][1].to_s}"
+              else
+                description = record[:data].to_s
+              end
+              printf "%25s  ", ''
+              printf "%5s".green, record[:type].to_s
+              printf "( ttl=%i ): %s\n", record[:ttl], description
+            end
+          end
+
+        end
+      end
+
+
+    end
+  end
+end

data/lib/blend/status/project.rb

@@ -0,0 +1,227 @@
+require 'blend/status/team'
+require 'blend/status/repo'
+require 'blend/status/domain'
+require 'blend/status/environment'
+require 'blend/status/project_resolver'
+
+module Blend
+  module Status
+    class Project
+      attr_accessor :name, :juice_id, :juice_client, :resolve
+
+      def initialize( name, resolve = false )
+        @name = name
+        @juice_client = Blend::Client.juice_client
+        reload
+        @resolve = resolve
+        @resolver = ProjectResolver.new( self )
+      end
+
+      def reload
+        @juice_id = @juice_client.project_id_from_name @name
+        @teams = nil
+        @repos = nil
+        @environment_status = nil
+        @domains_status = nil
+        @config = nil
+        @feeds = nil
+        @environments = nil
+      end
+
+
+      ##
+      # Sub status systems
+      ##
+
+      def team_status
+        @teams ||= (github_teams || []).collect do |team|
+          Team.new( self, team )
+        end
+      end
+
+      def repo_status
+        @repos ||= (repos || []).collect do |name, repo|
+          Repo.new( self, name, repo )
+        end
+      end
+
+      def environment_status
+        @environment_status ||= (servers || []).collect do |server|
+          Environment.new( self, server['name'], server['environment']['name'].downcase )
+        end
+      end
+
+      def domains_status
+        @domains_status ||= domains.collect do |x|
+          Domain.new( @project, x[:environment], x[:domain] )
+        end
+      end
+
+      ##
+      # Project Metadata
+      ##
+
+      def domains
+        environment_status.collect do |x| 
+          x.domains.collect do |domain|
+            {environment: x.environment, domain: domain }
+          end
+        end.flatten
+      end
+
+      def config
+        @config ||= (@juice_client.project( @juice_id ) || {})['blend_config']
+      end
+
+      def feeds
+        @feeds ||= @juice_client.feeds( @juice_id ).group_by { |x| x['feed_name'] }
+      end
+
+      def environments
+        @environments ||= @juice_client.environments( @juice_id ).group_by{|x| x['name'].downcase}
+      end
+
+      ##
+      # Checks
+      ##
+
+      def project_found
+        !@juice_id.nil? && @juice_id != ""
+      end
+
+      def read_only_teams
+        team_status.select { |team| team.read_only? }
+      end
+
+      def write_teams
+        team_status.select { |team| !team.read_only? }
+      end
+
+      def github_members
+        read_only_members = read_only_teams.collect { |ts| ts.members }.flatten
+        write_team_members = write_teams.collect { |ts| ts.members }.flatten
+
+        read_only_members -= write_team_members
+
+        write_team_members.collect do |x| 
+          {name: x, access: :full}
+        end + read_only_members.collect do |x| 
+          {name: x, access: :read}
+        end
+      end
+
+      def repos
+        ret = {}
+        team_status.each do |x|
+          x.repos.each do |repo|
+            ret[repo.full_name] = repo
+          end
+        end
+        ret
+      end
+
+      def repos_setup
+        repos.keys
+      end
+
+      def source_control
+        a = (feeds['github'] || []).collect { |x| "#{x['namespace']}/#{x['name']}" }
+        b = repos_setup
+
+        return false if (a-b).length != 0 || (b-a).length != 0
+        return false if a.length == 0 || b.length == 0
+        return a
+      end
+
+      def juice_users_synced_diff
+        team_juice_users = {}
+        github_members.each do |member|
+          user = juice_client.user_from_github_user member[:name]
+          team_juice_users[user['id']] = user if user
+        end
+
+        juice_users = juice_client.project_users( @juice_id ).group_by{ |x| x['id'] }
+
+        not_in_juice = team_juice_users.keys - juice_users.keys
+      end
+
+      def juice_users_synced
+        juice_users_synced_diff.length == 0
+      end
+
+      def servers( env = nil )
+        if( env )
+          (feeds['heroku'] || []).group_by { |x| x['environment']['name'].downcase }[env]
+        else
+          feeds['heroku']
+        end
+      end
+
+      def bugtracking
+        f = (feeds['asana'] || []) + (feeds['lighthouse'] || [])
+        return nil if f.length == 0
+        f
+      end
+
+      def production
+        environments['production']
+      end
+
+      def staging
+        environments['staging']
+      end
+
+      def heroku_apps( env = nil )
+        servers(env).collect { |x| [x['name'], x['environment']['name']]}
+      end
+
+      def hipchat
+        return nil if config.nil?
+        config['hipchat_room']
+      end
+
+      def github_teams
+        # return []] if @juice_id.nil?
+        return [] if config.nil?
+        config['teams'] 
+      end
+
+      def header text
+        puts
+        puts "#{text}".blue.underline
+      end
+
+      def check key, method
+        ret = __send__( method )
+        ret = false if ret.nil?
+        ret = false if ret.is_a? Array and ret.length == 0
+
+        pass = ret
+
+        if ret.is_a? Array
+          ret = ret.collect do |x|
+            if x.is_a? Hash
+              x[:name] || x['name']
+            else
+              x
+            end
+          end.join( ", ")
+        end
+
+        ret = "" if !ret
+
+        printf "%20s: ", key
+        if( pass )
+          printf "\u2713 #{ret}\n".encode('utf-8').green
+        else
+          printf "\u2718 #{ret}\n".encode('utf-8').red
+          if @resolve
+            r = "resolve_#{method}".to_sym
+            @resolver.__send__(r) if @resolver.respond_to? r
+            reload
+          end
+        end
+      end
+    end
+  end
+end