hyrb 0.0.2

data/lib/hyrb/tasks/environment.rb

@@ -0,0 +1,56 @@
+module Hyrb
+  module Tasks
+    module Environment
+      class Inject < Task
+        depends Project::Init
+
+        def run(env)
+          unless env.environment_name
+            if env.project.environments.any?
+              say "Environments: #{env.project.environments.keys.join(", ")}"
+            end
+
+            env.environment_name = ask "Environment", default: "production"
+          end
+
+          env.environment = Hyrb::Models::Environment.new(env.project, env.environment_name)
+          env.environment.label = env.project.name
+          env.environment.label += "-#{env.environment_name}" unless env.environment_name == "production"
+
+          prompt "Domain (FQDN)", env.environment, :domain, "#{env.environment.label}.#{env.defaults.domain}"
+
+          env.environment.save!
+        end
+      end
+
+      class Init < Task
+        depends Inject
+      end
+
+      class SetupExisting < Task
+        depends Init
+
+        prompt :environment, :host, default: ->(env) { env.environment.domain }
+      end
+
+      class Deployment < Task
+        depends SetupExisting
+
+        prompt :environment, :deploy_user, default: "deploy"
+        prompt :environment, :base_path, default: "/var/www"
+        prompt :environment, :relative_web_root, default: "/current/public"
+
+        def run(env)
+        end
+      end
+
+      class Database < Task
+        depends Deployment
+
+        prompt :environment, :database_host, default: "localhost"
+        prompt :environment, :database_name, default: ->(env) { env.environment.label.underscore }
+        prompt :environment, :database_user, default: ->(env) { env.environment.label.underscore }
+      end
+    end
+  end
+end

data/lib/hyrb/tasks/github.rb

@@ -0,0 +1,120 @@
+require 'octokit'
+
+module Hyrb
+  module Tasks
+    module Github
+      class Inject < Task
+        depends Creds::Init
+
+        prompt :creds, :github_org
+        prompt :creds, :github_api_key
+
+        def run(env)
+          env.github_client = Octokit::Client.new({
+            access_token: env.creds.github_api_key,
+            auto_pagination: true,
+          })
+        end
+      end
+
+      class Init < Task
+        depends Inject
+      end
+
+      class Repos < Task
+        depends Init
+
+        def run(env)
+          env.github_repos = env.github_client.org_repos(per_page: 100, org: env.creds.github_org)
+        end
+      end
+
+      class ShowRepos < Task
+        depends Repos
+
+        def run(env)
+          say env.github_repos.map(&:name).to_yaml
+        end
+      end
+
+      class CreateRepo < Task
+        depends Init, Project::Init
+
+        prompt :project, :github_org, default: ->(env) { env.creds.github_org }
+        prompt :project, :repo_name, default: ->(env) { env.project.name }
+
+        def run(env)
+          if env.github_repo = env.github_client.repository?(env.project.repo_path)
+            say "Github repo #{env.project.repo_path} exists", :yellow
+          else
+            # TODO: gitignore, teams
+            env.github_repo = env.github_client.create(env.project.repo_name, {
+              organization: env.project.github_org,
+              description: env.project.description,
+              private: true,
+            })
+            say "Created Github repo #{env.project.repo_path}", :green
+          end
+        end
+      end
+
+      class CreateProjectTeam < Task
+        depends CreateRepo, Developers::Init
+
+        prompt :project, :github_team, default: ->(env) { env.project.repo_name }
+
+        def run(env)
+          env.github_team = env.github_client.organization_teams(env.project.github_org).find do |t|
+            t.name == env.project.github_team
+          end
+
+          if env.github_team
+            say "Github team #{env.project.github_team} exists", :yellow
+          else
+            env.github_team = env.github_client.create_team(env.project.github_org, {
+              name: env.project.github_team,
+              repo_names: [env.project.repo_name],
+              permission: "push"
+            })
+            say "Created Github team #{env.project.github_team} exists", :green
+          end
+        end
+      end
+
+      class SyncProjectTeam < Task
+        depends CreateProjectTeam
+
+        def run(env)
+          team = env.github_team
+          new_devs = env.project.developers(env.developers)
+          current_members = env.github_client.team_members(team.id)
+
+          members_to_remove = current_members.reject do |member|
+            new_devs.map(&:github_username).include?(member.login)
+          end
+
+          devs_to_add = new_devs.reject do |dev|
+            current_members.map(&:login).include?(dev.github_username)
+          end
+
+          members_to_remove.each do |member|
+            if env.github_client.remove_team_member(team.id, member.login)
+              say "Removed #{member.login} from team #{env.project.github_org}/#{team.slug}", :green
+            else
+              say "Couldn't remove #{member.login} from team #{env.project.github_org}/#{team.slug}", :red
+            end
+          end
+
+          devs_to_add.each do |dev|
+            if env.github_client.add_team_member(team.id, dev.github_username)
+              say "Added #{dev.github_username} to team #{env.project.github_org}/#{team.slug}", :green
+            else
+              say "Couldn't add #{dev.github_username} to team #{env.project.github_org}/#{team.slug}", :red
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/hyrb/tasks/google.rb

@@ -0,0 +1,15 @@
+module Hyrb
+  module Tasks
+    module Google
+      class Init < Task
+        # depends Inject
+        depends Creds::Init
+
+        prompt :creds, :google_client_id
+        prompt :creds, :google_client_secret
+        prompt :creds, :google_refresh_token
+        prompt :creds, :google_spreadsheet_key
+      end
+    end
+  end
+end

data/lib/hyrb/tasks/hipchat.rb

@@ -0,0 +1,76 @@
+require 'hipchat-api'
+  
+module Hyrb
+  module Tasks
+    module Hipchat
+      class Inject < Task
+        depends Creds::Init
+
+        prompt :creds, :hipchat_api_key
+
+        def run(env)
+          env.hipchat_client = HipChat::API.new(env.creds.hipchat_api_key)
+        end
+      end
+
+      class Init < Task
+        depends Inject
+      end
+
+      class Rooms < Task
+        depends Init
+
+        def run(env)
+          env.hipchat_rooms = env.hipchat_client.rooms_list['rooms']
+        end
+      end
+
+      class ShowRooms < Task
+        depends Rooms
+
+        def run(env)
+          say env.hipchat_rooms.map { |r| "#{r.name} (#{r.room_id})" }.to_yaml
+        end
+      end
+
+      class CreateRoom < Task
+        depends Rooms, Project::Init
+
+        prompt :project, :room_name, default: ->(env) { env.project.title }
+        prompt :creds, :hipchat_user_id
+
+        def run(env)
+          # TODO: should unarchive room if it exists
+          if env.hipchat_rooms.any? { |r| r.name == env.project.room_name }
+            say "HipChat room #{env.project.room_name} exists", :yellow
+          else
+            env.hipchat_client.rooms_create(env.project.room_name, env.creds.hipchat_user_id,
+                                            'public', env.project.description)
+            say "Created HipChat room #{env.project.room_name}", :green
+          end
+        end
+      end
+
+      class ArchiveOldRooms < Task
+        depends Rooms
+
+        def run(env)
+          floor = Time.now - 3.months
+          say "Listing all unarchived room last active before #{floor}"
+          say "CTRL+C to exit"
+          old_rooms = env.hipchat_rooms.select do |room|
+            room["is_archived"] == false && room["last_active"] < floor.to_i
+          end
+
+          old_rooms.each do |room|
+            if yes? "Archive #{room["name"]}? (last active at #{Time.at(room["last_active"])})"
+              say "Hipchat does not support archiving rooms via the API :(", :red
+            else
+              say "Spared #{room["name"]}", :yellow
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyrb/tasks/project/bootstrap.rb

@@ -0,0 +1,88 @@
+module Hyrb
+  module Tasks
+    module Project
+      class CreateHipchatHook < Task
+        depends Hipchat::CreateRoom, Github::CreateRepo
+
+        def run(env)
+          hook = env.github_client.create_hook(env.project.repo_path, 'hipchat', {
+            room: env.project.room_name,
+            auth_token: env.creds.hipchat_api_key,
+          },{
+            active: true,
+            events: %w( commit_comment gollum issues issue_comment pull_request
+                        pull_request_review_comment push team_add ),
+          })
+
+          say "Created HipChat hook linking #{env.project.repo_path} to #{env.project.room_name}", :green
+          env.github_client.test_hook(env.project.repo_path, hook.id)
+          say "Test post sent!", :green
+          env.project.has_hipchat_hook = true
+          env.project.save!
+        end
+      end
+
+      class Bootstrap < Task
+        depends Project::Init
+
+        def run(env)
+          prompt "Project title", env.project, :title, env.project.name.humanize
+          prompt "Project description", env.project, :description
+
+          if ! env.project.users.try(:any?) || yes?("Update users for this project?")
+            invoke Developers::Download
+            invoke Developers::AddToProject
+          end
+
+          if ! env.project.repo_name && yes?("Should the project have a Github repo?")
+            invoke Github::CreateRepo
+          end
+
+          if ! env.project.github_team && yes?("Should the project have a Github team?")
+            invoke Github::CreateProjectTeam
+          end
+
+          if env.project.github_team
+            invoke Github::SyncProjectTeam
+          end
+
+          if ! env.project.room_name
+            invoke Hipchat::CreateRoom if yes? "Should the project have a Hipchat room?"
+          end
+
+          if env.project.repo_name && env.project.room_name && ! env.project.has_hipchat_hook
+            invoke CreateHipchatHook
+          end
+
+          if env.environment_name || yes?("Work on a project environment?")
+            invoke Environment::Init
+
+            if env.environment.host
+              say "Sever for evironment exists: #{env.environment.host}", :yellow
+            elsif yes?("Provision a server for this environment?")
+              provisioners = {
+                digital_ocean: Provision::DigitalOcean,
+                rackspace: Provision::Rackspace,
+              }
+
+              provider_name = ask "Provider:", { limited_to: provisioners.keys.map(&:to_s) }
+              invoke provisioners[provider_name.to_sym]
+            end
+
+            if ! env.environment.has_dns_record && yes?("Create a DNS record?")
+              invoke Rackspace::CreateDNSRecord
+            end
+
+            invoke Environment::SetupExisting
+
+            if yes? "Set up ansible for this environment?"
+              invoke Ansible::CreatePlaybook
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/hyrb/tasks/project.rb

@@ -0,0 +1,48 @@
+module Hyrb
+  module Tasks
+    module Project
+      autoload :Bootstrap, "hyrb/tasks/project/bootstrap"
+
+      class Inject < Task
+        depends Creds::Init
+
+        def run(env)
+          env.project = Hyrb::Models::Project.new(env.project_name || ask("Project name"))
+          env.project.save!
+        end
+      end
+
+      class Init < Task
+        depends Project::Inject
+      end
+
+      class Show < Task
+        depends Project::Init
+
+        def run(env)
+          say env.project.data.to_hash.to_yaml
+        end
+      end
+
+      class Edit < Task
+        depends Project::Init
+
+        def run(env)
+          edit(env.project.filepath)
+        end
+      end
+
+      class Create < Task
+        depends Project::Init
+
+        def run(env)
+          prompt "Project title", env.project, :title, env.project.name.humanize
+          prompt "Project description", env.project, :description
+          prompt "Github org", env.project, :github_org, env.creds.github_org
+          prompt "Github repo", env.project, :repo_name, env.project.name
+          prompt "Hipchat room", env.project, :room_name, env.project.name
+        end
+      end
+    end
+  end
+end

data/lib/hyrb/tasks/provision.rb

@@ -0,0 +1,91 @@
+require 'fog/digitalocean'
+require 'fog/rackspace'
+require 'parallel'
+
+module Hyrb
+  module Tasks
+    module Provision
+      class Init < Task
+        depends Environment::Init
+
+        prompt :environment, :server_name, default: ->(env) { env.environment.domain || env.environment.label }
+      end
+
+      class DigitalOcean < Task
+        depends Init, Hyrb::Tasks::DigitalOcean::SSHKeys, Developers::AddToProject
+
+        def run(env)
+          ssh_key_ids = env.project.developers(env.developers).map(&:digital_ocean_id).compact
+
+          flavor_id = option_list(env.digital_ocean_cache, :flavors, 2) do |f, i|
+            "#{i+1}: #{f.name} ram / #{f.cpu} cpu / #{'$%.2f/mo' % f.cost_per_month}"
+          end.id
+
+          image_id = option_list(env.digital_ocean_cache, :images, 16) do |f, i|
+            "#{i+1}: #{f.name} / id: #{f.id}"
+          end.id
+
+          region_id = option_list(env.digital_ocean_cache, :regions, 2) do |f, i|
+            "#{i+1}: #{f.name} / id: #{f.id}"
+          end.id
+
+          say "Creating Digital Ocean Server"
+          server = env.digital_ocean_client.servers.create({
+            name: env.environment.server_name,
+            flavor_id: flavor_id,
+            image_id: image_id,
+            region_id: region_id,
+            ssh_key_ids: ssh_key_ids,
+          })
+
+          env.environment.provider = 'digital_ocean'
+          env.environment.server_id = server.id
+
+          sleep(4) until server.reload.ready?
+          env.environment.host = server.public_ip_address
+
+          env.environment.save!
+
+          say "Created Digital Ocean Server!", :green
+          say "IP Address: #{server.public_ip_address} / ID: #{server.id}", :green
+          say "\n\tssh root@#{server.public_ip_address}\n"
+          beep
+        end
+      end
+
+      class Rackspace < Task
+        depends Init, Hyrb::Tasks::Rackspace::Init
+
+        def run(env)
+          flavor_id = option_list(env.rackspace_cache, :flavors, 2) do |f, i|
+            "#{i+1}: #{f.name} / id: #{f.id}"
+          end.id
+
+          image_id = option_list(env.rackspace_cache, :images, 1) do |f, i|
+            "#{i+1}: #{f.name} / id: #{f.id}"
+          end.id
+
+          say "Creating Rackspace Server"
+          server = env.rackspace_client.servers.create({
+            name: env.environment.server_name,
+            flavor_id: flavor_id,
+            image_id: image_id,
+          })
+
+          env.environment.provider = 'rackspace'
+          env.environment.server_id = server.id
+
+          sleep(6) until server.reload.ready?
+          env.environment.host = server.public_ip_address
+
+          env.environment.save!
+
+          say "Created Rackspace Server!", :green
+          say "IP Address: #{server.public_ip_address} / ID: #{server.id}", :green
+          say "\n\tssh root@#{server.public_ip_address}\n"
+          beep
+        end
+      end
+    end
+  end
+end

data/lib/hyrb/tasks/rackspace.rb

@@ -0,0 +1,95 @@
+require 'ipaddr'
+
+require 'parallel'
+require 'fog/rackspace'
+
+module Hyrb
+  module Tasks
+    module Rackspace
+      class Inject < Task
+        depends Creds::Init
+
+        prompt :creds, :rackspace_username
+        prompt :creds, :rackspace_api_key
+        prompt :defaults, :rackspace_region, default: ->(env) { env.rackspace_region }
+
+        def run(env)
+          env.rackspace_client = Fog::Compute.new({
+            provider: 'rackspace',
+            rackspace_username: env.creds.rackspace_username,
+            rackspace_api_key: env.creds.rackspace_api_key,
+            version: :v2,
+            rackspace_region: env.defaults.rackspace_region,
+          })
+
+          env.rackspace_dns_client = Fog::DNS.new({
+            provider: 'rackspace',
+            rackspace_username: env.creds.rackspace_username,
+            rackspace_api_key: env.creds.rackspace_api_key,
+            rackspace_region: env.defaults.rackspace_region,
+          })
+        end
+      end
+
+      class Init < Task
+        depends Inject
+
+        def run(env)
+          env.rackspace_cache = Hyrb::Models::Cache::Rackspace.new
+          env.rackspace_cache.class.keys.each do |key|
+            env.rackspace_cache[key] ||= env.rackspace_client.send(key).map(&:attributes)
+          end
+          env.rackspace_cache.save!
+        end
+      end
+
+      class DNSZones < Task
+        depends Init
+
+        def run(env)
+          env.rackspace_dns_zones = env.rackspace_dns_client.zones
+        end
+      end
+
+      class CreateDNSRecord < Task
+        depends DNSZones, Environment::Init
+
+        prompt :environment, :domain, default: ->(env) { "#{env.environment.label}.#{env.defaults.domain}" }
+        prompt :environment, :host
+
+        def run(env)
+          record_type = (IPAddr.new(env.environment.host) rescue false) ? 'A' : 'CNAME'
+
+          # assume zone is going to be x.com
+          proj_zone = env.environment.domain.split('.')[-2..-1].join('.')
+
+          zone = env.rackspace_dns_zones.find { |z| z.domain == proj_zone }
+          zone ||= env.rackspace_dns_client.zones.create({
+            domain: proj_zone,
+            email: env.defaults.admin_email,
+          })
+
+          record = zone.records.find do |r|
+            r.name == env.environment.domain && r.type == record_type
+          end
+
+          if record
+            say "Record exists: '#{record.type} #{record.name} #{record.value} (#{record.ttl})'", :yellow
+          else
+            record = zone.records.create({
+              name: env.environment.domain,
+              value: env.environment.host,
+              type: record_type,
+              ttl: 300,
+            })
+            say "Created record: '#{record.type} #{record.name} #{record.value} (#{record.ttl})'", :green
+          end
+          env.environment.has_dns_record = true
+          env.environment.save!
+          beep
+        end
+      end
+
+    end
+  end
+end

data/lib/hyrb/version.rb

@@ -0,0 +1,3 @@
+module Hyrb
+  VERSION = "0.0.2"
+end

data/lib/hyrb.rb

@@ -0,0 +1,18 @@
+require 'hashie/mash'
+require 'active_support/core_ext'
+require 'pry'
+
+require 'hyrb/version'
+
+module Hyrb
+  DEFAULT_PATH = File.join(File.expand_path("~"), ".hyfn")
+  TEMPLATE_PATH = File.join(File.dirname(__FILE__), "templates")
+
+  def self.autoload_each(base, base_path, files)
+    files.each {|f| base.autoload f.camelcase.to_sym, "#{base_path}/#{f}" }
+  end
+end
+
+require 'hyrb/pipeline'
+require 'hyrb/task'
+require 'hyrb/model'

data/lib/templates/ansible/Vagrantfile.erb

@@ -0,0 +1,21 @@
+Vagrant.configure("2") do |config|
+  config.ssh.forward_agent = true
+
+  config.vm.box = "raring64"
+  config.vm.box_url = "http://cloud-images.ubuntu.com/vagrant/raring/current/raring-server-cloudimg-amd64-vagrant-disk1.box"
+
+  config.vm.hostname = "<%= project.name %>"
+  config.vm.network :private_network, ip: "33.33.33.10"
+  config.vm.provision :ansible do |ansible|
+    ansible.playbook = "roles/lamp.yml"
+    ansible.verbose = true
+  end
+
+  config.vm.provider :virtualbox do |provider|
+    # Don't boot with headless mode
+    # vb.gui = true
+
+    # Use VBoxManage to customize the VM. For example to change memory:
+    # vb.customize ["modifyvm", :id, "--memory", "1024"]
+  end
+end

data/lib/templates/ansible/roles/db/handlers/main.yml

@@ -0,0 +1,2 @@
+- name: restart mysql
+  service: name=mysql state=restarted enabled=yes

data/lib/templates/ansible/roles/db/tasks/main.yml

@@ -0,0 +1,24 @@
+---
+- name: mysql | install
+  apt: "pkg={{item}} state=latest"
+  with_items:
+    - mysql-client
+    - mysql-server
+    - python-mysqldb
+
+- name: mysql | start
+  service: name=mysql state=started
+
+- name: mysql | create root user
+  mysql_user: "name=root password=root state=present host='{{ item }}'"
+  with_items:
+    - 127.0.0.1
+    - "{{ ansible_hostname }}"
+    - ::1
+    - localhost
+  ignore_errors: true
+
+- name: mysql | set bind address
+  lineinfile: regexp=^bind-address line="bind_address=0.0.0.0" dest=/etc/mysql/my.cnf state=present
+  notify:
+    - restart mysql