blend 0.1.4

data/lib/blend/client.rb

@@ -0,0 +1,63 @@
+require 'blend/client/hipchat_client'
+require 'blend/client/github_client'
+require 'blend/client/juice_client'
+require 'blend/client/heroku_client'
+
+module Blend
+  module Client
+    class << self
+      def hipchat_client
+        @hipchat_client ||= Blend::Client::HipchatClient.new( HipChat::API.new( get_token( :hipchat ) ) )
+      end
+
+      def github_client
+        @github_client ||= Blend::Client::GithubClient.new( Github.new( oauth_token: get_token( :github ) ) )
+      end
+
+      def juice_client( options = {} )
+        if( options[:auth_token] )
+          if( @juice_client && @juice_client.auth_token != options[:auth_token] )
+            @juice_client = nil
+            @hipchat_client = nil
+            @github_client = nil
+          end
+
+          @juice_client ||= Blend::Client::JuiceClient.new options
+        end
+        
+        @juice_client ||= Blend::Client::JuiceClient.new
+      end
+
+      def heroku_client
+        @heroku_client ||= Blend::Client::HerokuClient.new( Heroku::API.new( api_key: get_token( :heroku ) ) )
+      end
+
+      def get_token( type )
+        token = case type
+
+        #when :juice
+          # Don't use this. This is already handled together with the login
+          # stuff in JuiceClient. It could be refactored to fit in with this
+          # method a little better, but what'd be the point? It works and
+          # it's straightforward.
+        when :hipchat
+          ENV['HIPCHAT_API_TOKEN'] || juice_client.hipchat_api
+        when :github
+          ENV['GITHUB_API_TOKEN'] || juice_client.auth( "github" )
+        when :heroku
+          # Opt for the organization-wide heroku api token:
+          ENV['HEROKU_API_TOKEN'] || juice_client.heroku_api
+          # Instead of per-user heroku auth:
+          #ENV['HEROKU_API_TOKEN'] || juice_client.auth( "heroku" )
+        else
+          throw "Unknown token type #{type}".red
+        end
+
+        
+        throw "Token not found for #{type}" if token.nil? || token == ""
+
+        token
+      end
+    end
+  end
+end

data/lib/blend/client/github_client.rb

@@ -0,0 +1,106 @@
+module Blend
+  module Client
+    class GithubClient
+      attr_accessor :client
+
+      def initialize( client )
+        @client = client
+      end
+
+      def list_repos( filter = nil )
+        return @repos if @repos && filter.nil?
+
+        repos = []
+        @client.repos.list( org: "sublimeguile" ).each_page do |page|
+          page.each do |r|
+            repos << r
+          end
+        end
+
+        if filter
+          repos = repos.select { |x| x['name'] =~ /#{filter}/ }
+        end
+
+        repos = repos.sort do |a,b| 
+          a['name'] <=> b['name']
+        end
+
+        @repos = repos if filter.nil?
+        repos
+      end
+
+      def repo_create( team, name )
+        require 'pp'
+        pp @client.repos.create org: "sublimeguile", name: name, public: false, private: true
+        add_team_repo( team, "sublimeguile/#{name}" )
+      end
+
+
+      def list_collaborators( repo )
+        @client.repos.collaborators.list *repo.split( /\// )
+      end
+
+      def list_hooks( repo )
+        @client.repos.hooks.list( *repo.split( /\// ) )
+      end
+
+      def add_hook( repo, name, config )
+        @client.repos.hooks.create *repo.split( /\// ), name: name, config: config
+      end
+
+      def list_teams
+        @client.orgs.teams.list "sublimeguile"
+      end
+
+      def find_team_from_name( name )
+        list_teams.select { |x| x['name'] == name }
+      end
+
+      def list_team( team )
+        find_team_from_name( team ).first
+      end
+
+      def list_team_repos( team )
+        find_team_from_name(team).each do |x|
+          return @client.orgs.teams.repos x.id
+        end
+      end
+
+      def list_team_members( team )
+        find_team_from_name(team).each do |x|
+          return @client.orgs.teams.list_members x.id
+        end
+      end
+
+      def create_team( team )
+        @client.orgs.teams.create "sublimeguile", { name: team, permission: "push" }
+      end
+
+      def add_team_member( team, user )
+        find_team_from_name( team ).each do |x|
+          return @client.orgs.teams.add_member x.id, user
+        end
+      end
+
+      def remove_team_member( team, user)
+        find_team_from_name( team ).each do |x|
+          return @client.orgs.teams.remove_member x.id, user
+        end
+      end
+
+      def add_team_repo( team, repo )
+        user,name = repo.split( /\// )
+        find_team_from_name( team ).each do |x|
+          return @client.orgs.teams.add_repo x.id, user, name
+        end
+      end
+
+      def remove_team_repo( team, repo )
+        user,name = repo.split( /\// )
+        find_team_from_name( team ).each do |x|
+          return @client.orgs.teams.remove_repo x.id, user, name
+        end
+      end
+    end
+  end
+end

data/lib/blend/client/heroku_client.rb

@@ -0,0 +1,87 @@
+require 'highline/import'
+
+module Blend
+  module Client
+    class HerokuClient
+
+      attr_accessor :client
+      
+      def initialize( client )
+        @client = client
+        @addons = {}
+      end
+        
+      def info( app )
+        client.get_app(app).body
+      end
+
+      def domains( app ) 
+        client.get_domains(app).body
+      end
+
+      def nonheroku_domains( app )
+        domains(app).reject{|x| x['base_domain']=="herokuapp.com" || x['domain'] =~ /^www/}.collect{|x| x['domain']}
+      end
+
+      def addons( app, filter=nil )
+        @addons[app] ||= client.get_addons(app).body
+        if filter.nil?
+          @addons[app]
+        else
+          @addons[app].select{|x| x['name'] =~ filter}
+        end
+      end
+
+      def addon_names( app, filter )
+        addons(app, filter).collect do |addon|
+         name,plan = addon['name'].split(/:/)
+         {name: name, plan: plan}
+        end
+      end
+
+      def addon_matches( app, addon_name )
+        addons(app).select{|x| x[:name] =~ addon_name}
+      end
+
+      def stack(app)
+        info(app)['stack']
+      end
+
+      def dynos( app )
+        info(app)['dynos']
+      end
+
+      def backups( app )
+        addon_names(app, /pgbackups/)
+      end
+
+      def databases( app )
+        addon_names(app, /postgresq/)
+      end
+
+      def run_domain_checker( app )
+        results = {}
+        nonheroku_domains(app).map{|x| x['domain']}.each do |d|
+
+
+          DomainChecker.check(d)
+
+          result = {}
+          results[d] = result
+
+          # Check registered
+          result[:registered] = dc.registered?
+
+          # Check registrar
+          result[:registrar] = dc.registrar
+
+          result[:ssl] = dc.ssl
+        end
+
+        results
+
+      end
+
+    end
+  end
+end

data/lib/blend/client/hipchat_client.rb

@@ -0,0 +1,78 @@
+module Blend
+  module Client
+    class HipchatClient
+      attr_accessor :api
+
+      def initialize( api )
+        @api = api
+      end
+
+      def create_room( name, topic )
+        creator = user_by_name 'Will Schenk'
+
+        ret =  api.rooms_create name, creator['user_id'], 'public', topic
+
+        if ret["error"]
+          pp ret["error"]
+        end
+
+        @rooms = nil
+      end
+
+      def rooms
+        @rooms ||= api.rooms_list.parsed_response['rooms']
+        raise Exceptions::HipchatAuthenticationFailure if @rooms.nil?
+        @rooms
+      end
+
+      def room_name_from_xmpp_jid( name )
+        rooms.select{|x| x['xmpp_jid'] == name}.first['name'] rescue nil
+      end
+
+      def room_by_name( name )
+        rooms.each do |r|
+          return r if r['name'] == name
+        end
+
+        puts "Room #{name} not found".red
+        nil
+      end
+
+      def room_info( name )
+        room = room_by_name name
+
+        if( room )
+          api.rooms_show( room['room_id'] ).parsed_response['room']
+        end
+      end
+
+      def users
+        @users ||= api.users_list.parsed_response['users']
+      end
+
+      def user_by_name( name )
+        users.each do |u|
+          return u if u['name'] == name
+        end
+
+        puts "User #{name} not found".red
+      end
+
+      def set_topic( room, topic )
+        room = room_by_name room
+
+        if room
+          api.rooms_topic( room['room_id'], topic)
+        end
+      end
+
+      def post_message( room, message, color = 'yellow', notify = false, type = 'text' )
+        room = room_by_name room
+
+        if room
+          api.rooms_message room['room_id'], 'hfc', message, notify ? "1" : "0", color, type
+        end
+      end
+    end
+  end
+end

data/lib/blend/client/juice_client.rb

@@ -0,0 +1,400 @@
+require 'highline/import'
+
+module Blend
+  module Client
+    class JuiceClient
+      include HTTParty
+
+      class << self
+        
+        # Wrap HHTParty's get method so we can actually catch errors
+        def get( url, *args )
+          response = super( url, *args )
+          case response.code
+            when 401
+              raise Exceptions::AuthenticationFailure
+          end
+          return response
+        end
+
+        def post( url, *args )
+          response = super( url, *args )
+          case response.code
+            when 401
+              raise Exceptions::AuthenticationFailure
+          end
+          return response
+        end
+
+      end
+
+      def initialize(opts={})
+        @options = {}
+        @options['auth_token'] = opts[:auth_token] if opts.include? :auth_token
+      end
+
+      base_uri ENV['JUICE_API_ENDPOINT'] || 'http://happyfunjuice.com/api'
+      # debug_output $stderr
+      
+      def login
+        query_login
+      end
+
+      def logout
+        destroy_auth_token
+      end
+
+      def create_project( name )
+        auth_token
+        pp self.class.post "/organizations/1/projects", { query: { "project[name]" => name } }
+        @projects = nil
+      end
+
+      def profile
+        auth_token
+        @projects ||= self.class.get( "/user.json" )
+      end
+
+      def projects
+        auth_token
+        @projects ||= self.class.get( "/projects.json" ).each do |x|
+          x['blend_config'] ||= {}
+          x['blend_config']['teams'] ||= []
+        end
+      end
+
+      def summary
+        auth_token
+        @projects ||= self.class.get( "/projects/summary.json" ).each do |x|
+          x['blend_config'] ||= {}
+          x['blend_config']['teams'] ||= []
+        end
+      end
+
+      def organizations
+        auth_token
+        @organizations ||= self.class.get( "/organizations.json" ).each do |o|
+          o['blend_config'] ||= {}
+        end
+      end
+
+      def project_info_from_room( room )
+        auth_token
+        if room =~ /[0-9]+_[^@]+@.*/
+          room_name = Blend::Client.hipchat_client.room_name_from_xmpp_jid( room )
+        else
+          room_name = room
+        end
+        return nil if room_name.nil? or room_name.length==0
+        projects.select{|x| (x['blend_config']['hipchat_room'].downcase rescue nil) == room_name.downcase}.first
+      end
+
+      def project_id_from_room( room )
+        @project_ids_from_rooms ||= {}
+        p = project_info_from_room( room )
+        if p.nil?
+          nil
+        else
+          @project_ids_from_rooms[room] ||= p['id']
+        end
+      end
+
+      def project_id_from_name( name )
+        return name if name.to_s =~ /^[0-9]+$/
+
+        projects.each do |project|
+          return project['id'] if project['name'].projectize == name.projectize
+        end
+
+        puts "Couldn't find project #{name.projectize}"
+        nil
+      end
+
+      def project( id )
+        return nil if id.nil?
+
+        auth_token
+        data = self.class.get "/projects/#{id}.json"
+
+        data['blend_config'] ||= {}
+        data['blend_config']['teams'] ||= []
+
+        data
+      end
+
+      def lookup_user( query )
+        auth_token
+        self.class.get "/users/lookup.json", { query: { query: query } }
+      end
+
+      def search_users( query )
+        auth_token
+        self.class.get "/users/search.json", { query: { query: query } }
+      end
+
+      def user_from_github_user( github )
+        @github_users ||= {}
+        @github_users[github] ||= search_users(github).select { |x| x['github_handle'] == github }.first
+      end
+
+      def organization_users( id )
+        auth_token
+        self.class.get "/organizations/#{id}/users.json"
+      end
+
+      def project_users( id )
+        auth_token
+        self.class.get "/projects/#{id}/users.json"
+      end
+
+      def project_add_user( project_id, user_id )
+        auth_token
+        self.class.post "/projects/#{project_id}/users/#{user_id}"
+      end
+
+      def project_config( id, config = nil )
+        auth_token
+        if( config.nil? )
+          puts "Loading config"
+          project = self.class.get "/projects/#{id}.json"
+          project['blend_config'] || {}
+        else
+          puts "Setting config #{config}"
+          self.class.put "/projects/#{id}.json", { query: { project: { blend_config: config } } }
+          @projects = nil
+        end
+      end
+
+      def project_add_team( id, github_team )
+        config = project_config( id )
+        config['teams'] ||= []
+        config['teams'] << github_team
+        project_config( id, config )
+      end
+
+      def project_add_hipchat( id, hipchat )
+        config = project_config( id )
+        config['hipchat_room'] = hipchat
+        project_config( id, config )
+      end
+
+      def feeds( id )
+        auth_token
+        self.class.get "/projects/#{id}/feeds.json"
+      end
+
+      def add_feed( project_id, feed_type, key, environment = nil )
+        auth_token
+        self.class.post "/projects/#{project_id}/feeds", {query: { feed_type: feed_type, key: key } }
+      end
+
+      def environments( id )
+        auth_token
+        self.class.get "/projects/#{id}/environments.json"
+      end
+
+      def heroku_apps( id )
+        auth_token
+        f = feeds( id ).group_by{|x| x['feed_name']}
+        (f['heroku'] || []).group_by { |x| x['environment']['name'].downcase}
+      end
+
+      def auths
+        auth_token
+        @auths ||= self.class.get "/profile/authentications.json"
+      end
+
+      def auth( provider )
+        auths.select do |x|
+          return x['token'] if x['provider'] == provider
+        end
+
+        nil
+      end
+
+      def activities( project_id, after, before = Time.now )
+        auth_token
+        activities = self.class.get "/projects/#{project_id}/activities.json", {query: { after: after.to_i, before: before.to_i } }
+        activities_stats activities, after, before # <-- so activities actually returns activities_stats? That's... weird.
+      end
+
+      def activities_stats( activities, after, before )
+        stats = { type: {}, 
+                  actors_activites: {}, 
+                  activities: activities, 
+                  after: after, 
+                  before: before, 
+                  active_tickets: {},
+                  closed_tickets: {}}
+
+        activities.each do |x|
+          x['happened_at'] = Time.parse x['happened_at']
+        end.sort do |a,b|
+          a['happened_at'] <=> b['happened_at']
+        end.each do |a|
+          actor = a['actor_identifier']
+          type = a['activity_type']
+          stats[:type][type] ||= []
+          stats[:type][type] << a
+
+          if( !(type =~ /^juice/) && !(type =~ /tweet/) )
+            stats[:actors_activites][type] ||= {}
+            stats[:actors_activites][type][actor] ||= []
+            stats[:actors_activites][type][actor] << a
+          end
+        end
+
+        stats
+      end
+
+      def heroku_api( token = nil )
+        auth_token
+        ret = {}
+        if( token )
+          ret = self.class.post "/organizations/1/heroku/api_token.json", {query: {heroku_api_token: token}}
+        else
+          ret = self.class.get "/organizations/1/heroku/api_token.json"
+        end
+        ret['heroku_api_token']
+      end
+
+
+      def hipchat_api( token = nil )
+        auth_token
+        ret = {}
+        if( token )
+          ret = self.class.post "/organizations/1/hipchat/auth_token.json", {query: {hipchat_auth_token: token}}
+        else
+          ret = self.class.get "/organizations/1/hipchat/auth_token.json"
+        end
+        ret['hipchat_auth_token']
+      end
+
+      def hipchat_check
+        hipchat_client = Blend::Client.hipchat_client
+
+        rooms = {}
+        hipchat_client.rooms.each { |x| rooms[x['name']] = [] }
+
+        projects.each do |project|
+          room = project['blend_config']['hipchat_room']
+          if room
+            rooms[room] ||= []
+            rooms[room] << project['name']
+          end
+        end
+
+        rooms.keys.sort { |a,b| a <=> b }.collect do |room|
+          if rooms[room].size == 0
+            rooms[room] << "_unassigned_"
+          end
+          { room: room, projects: rooms[room] }
+        end
+      end
+
+      def github_team_check
+        github_client = Blend::Client.github_client
+
+        teams = {}
+        github_client.list_teams.each do |team|
+          teams[team.name] = []
+        end
+
+        projects.each do |project|
+          project['blend_config']['teams'].each do |x|
+            teams[x] << project
+          end
+        end
+
+        teams
+      end
+
+
+      def config_file
+        "#{ENV['HOME']}/.juice.yml"
+      end
+
+      def destroy_auth_token
+        _prev_options = @options
+        begin
+          return File.delete config_file
+        rescue Errno::ENOENT
+          raise Exceptions::AlreadyLoggedOut
+        ensure
+          @options = {}
+        end
+        _prev_options
+      end
+
+      
+      def check_credentials( username, password )
+        response = self.class.post '/auth', {body: {username: username, password: password}}
+        raise Exceptions::LoginAuthenticationFailure if response['auth_token'].nil?
+        @options = response.parsed_response if @options['auth_token'].nil?
+      end
+
+
+      def query_login
+
+        begin
+          response = read_auth_token
+          @options = response
+
+          # If it doesn't contain an auth_token, it's as good as not existing:
+
+          raise Exceptions::AlreadyLoggedIn
+
+        rescue Errno::ENOENT
+          username = ask( "Username : " ) { |q| q.echo = true }
+          password = ask( "Password : " ) { |q| q.echo = '.' }
+
+          @options = check_credentials( username, password )
+
+          write_auth_token( @options )
+        end
+      end
+
+
+      def read_auth_token
+        begin
+          response = YAML.load( File.read( config_file ) )
+          raise StandardError.new unless response['auth_token']
+          response
+        rescue StandardError
+          raise Errno::ENOENT
+        end
+      end
+
+
+      def write_auth_token( options )
+        File.open( config_file, "w" ) do |o|
+          o.puts YAML.dump( options || {} )
+        end
+        return options
+      end
+
+
+      def auth_token
+
+        # Just return it if it's been set manually. This is accomplished when client is
+        # instantiated with JuiceClient.new(auth_token: ---)
+        if !@options['auth_token'].nil?
+          self.class.default_params auth_token: @options['auth_token']
+          return @options['auth_token']
+        end
+
+        if ENV['JUICE_AUTH_TOKEN'].nil?
+          begin
+            query_login
+          rescue Exceptions::AlreadyLoggedIn
+          end
+        else
+          @options = { 'auth_token' => ENV['JUICE_AUTH_TOKEN'] }
+        end
+        self.class.default_params auth_token: @options['auth_token']
+        @options['auth_token']
+      end
+
+    end
+  end
+end