meroku 0.0.0 → 0.1.28

data/lib/meroku/cli/server.rb

@@ -0,0 +1,159 @@
+module Meroku
+  module CLI
+    require 'action_view'
+    include ActionView::Helpers::TextHelper
+
+    class Server < Thor
+      include Meroku::Sanitychecks
+      include Meroku::Util
+
+      desc "_downall", "Wip"
+      def _downall()
+        admin_secrets_required
+        ec2_client.terminate_instances({ instance_ids: [ production_servers.first ] }) if !production_servers.empty?
+      end
+      
+      desc "revert", "Puts server in state it was in when it was started and installed"
+      def revert()
+        puts `ssh -o 'StrictHostKeyChecking=no' -i ~/crypto/meroku/meroku.id_rsa ubuntu@34.239.241.218 'cd ~/meroku/ && git pull'`
+        puts `ssh -o 'StrictHostKeyChecking=no' -i ~/crypto/meroku/meroku.id_rsa ubuntu@34.239.241.218 'sudo ~/meroku/rails_app/script/revert'`
+      end
+
+      desc "backup", "Backup databases in production server"
+      def backup()
+        admin_secrets_required
+        timestamp=Time.now.to_i
+        aws_exports="AWS_DEFAULT_REGION=us-east-1 AWS_ACCESS_KEY_ID=#{ENV['AWS_ACCESS_KEY_ID']} AWS_SECRET_ACCESS_KEY=#{ENV['AWS_SECRET_ACCESS_KEY']}"
+
+        if production_servers.empty?
+          puts "Not doing backup - No production servers"
+          return
+        end
+
+        # DBs
+        ssh3("34.239.241.218","PGPASSWORD=bitnami pg_dumpall -U postgres -f /tmp/#{timestamp}.postgres")
+        ssh3("34.239.241.218","mysqldump -uroot -pbitnami --all-databases > /tmp/#{timestamp}.mysql")
+        ssh3("34.239.241.218","gzip -fv -9 /tmp/#{timestamp}.postgres /tmp/#{timestamp}.mysql")
+        ssh("34.239.241.218","#{aws_exports} aws s3 cp /tmp/#{timestamp}.postgres.gz s3://meroku-database-backups/")
+        ssh("34.239.241.218","#{aws_exports} aws s3 cp /tmp/#{timestamp}.postgres.gz s3://meroku-database-backups/postgres.gz")
+        ssh("34.239.241.218","#{aws_exports} aws s3 cp /tmp/#{timestamp}.mysql.gz s3://meroku-database-backups/")
+        ssh("34.239.241.218","#{aws_exports} aws s3 cp /tmp/#{timestamp}.mysql.gz s3://meroku-database-backups/mysql.gz")
+
+        # HOME DIRS
+        ssh3("34.239.241.218","sudo rm -f /tmp/home_dirs.tgz || true; sudo tar --exclude='/home/bitnami' -zcvf /tmp/home_dirs.gz /home/*")
+        ssh("34.239.241.218","#{aws_exports} aws s3 cp /tmp/home_dirs.gz s3://meroku-database-backups/")
+        ssh("34.239.241.218","#{aws_exports} aws s3 cp s3://meroku-database-backups/home_dirs.gz  s3://meroku-database-backups/#{timestamp}.home_dirs.gz")
+        # CLEANUP
+        ssh("34.239.241.218","sudo rm -f /tmp/*.mysql.gz /tmp/*.postgres.gz /tmp/home_dirs.gz")
+      end
+      
+      desc "activate", "Assigns production elastic ip to standby node"
+      def activate()
+        admin_secrets_required
+        # Terminate server with production ip
+        if !production_servers.empty?
+          ec2_client.terminate_instances({ instance_ids: [ production_servers.first ] })
+        end
+
+        standby_servers = unused_servers
+        abort "Too many unused servers (#{standby_servers.size})" if standby_servers.size > 1
+
+        ec2_client.associate_address(
+          {
+            allocation_id: 'eipalloc-139f7823', # this is eip 34.239.241.218
+            instance_id: standby_servers.first
+          }
+        )
+        puts "Associated 34.239.241.218 with #{standby_servers.first}"
+        puts 'ping 34.239.241.218 -c 20'
+        puts `ping 34.239.241.218 -c 20`
+        puts `ssh -i ~/crypto/meroku/meroku.id_rsa -o "StrictHostKeyChecking=no" -v ubuntu@34.239.241.218 pwd`
+        # remove the next 3 lines later
+        ssh3("34.239.241.218","cat meroku/rails_app/tmp/pids/server.pid")
+        ssh3("34.239.241.218","kill -9 `cat meroku/rails_app/tmp/pids/server.pid`")
+        ssh3("34.239.241.218","cd meroku/rails_app; RAILS_SERVE_STATIC_FILES=1 SECRET_KEY_BASE=fixme rails s -e production -d -b 0.0.0.0 && sleep 5")
+        ssh3("34.239.241.218","sudo ls -la /opt/bitnami/nginx/conf/vhosts/") # for debugging
+      end
+
+      desc "install", "installs software needed to meroku work"
+      def install()
+        admin_secrets_required
+        ip = server_being_built
+
+        ssh2(ip,"sudo apt-add-repository ppa:git-core/ppa -y")
+        ssh2(ip,"sudo apt-get update -y")
+        ssh2(ip,"sudo apt-get install -yqq libyaml-dev libsqlite3-dev sqlite3 libgmp-dev libgdbm-dev")
+        ssh2(ip,"sudo apt-get install -yqq libncurses5-dev bison pkg-config libffi-dev")
+        ssh2(ip,"sudo apt-get install -yqq libgmp-dev libreadline6-dev libssl-dev libpq-dev libmysqlclient-dev jq awscli")
+        #ssh2(ip,"sudo apt-get install -yqq nodejs")
+        ssh2(ip,"sudo npm install -g yarn")
+
+        ssh2(ip,"sudo apt-get install git-core -y")
+        ssh2(ip,"sudo rm /opt/bitnami/git/bin/git")
+        ssh2(ip,"sudo ln -s /usr/bin/git /opt/bitnami/git/bin/git")
+
+        ssh2(ip,"sudo addgroup meroku;")
+        ssh2(ip,"sudo apt-get install emacs24-nox -y")
+        ssh2(ip,"git clone --quiet https://github.com/meroku/meroku.git")
+
+        ssh2(ip,"sudo mkdir /opt/githooks; sudo chmod 777 /opt/githooks")
+        ssh2(ip,'cp ~/meroku/misc/githook_post-receive /opt/githooks/post-receive')
+        ssh2(ip,'cp ~/meroku/misc/app_id_by_name /opt/githooks/app_id_by_name')
+        ssh2(ip,'cp ~/meroku/misc/user_id_by_name /opt/githooks/user_id_by_name')
+        
+        ssh2(ip,"sudo chmod 777 /opt/githooks/* ")
+        ssh2(ip,"sudo ln -s /usr/bin/install /bin/install")
+
+        aws_exports="AWS_DEFAULT_REGION=us-east-1 AWS_ACCESS_KEY_ID=#{ENV['AWS_ACCESS_KEY_ID']} AWS_SECRET_ACCESS_KEY=#{ENV['AWS_SECRET_ACCESS_KEY']}"
+
+        # postgres / mysql restore happens here
+        ssh3(ip,"#{aws_exports} aws s3 cp s3://meroku-database-backups/postgres.gz /tmp/")
+        ssh3(ip,"#{aws_exports} aws s3 cp s3://meroku-database-backups/mysql.gz /tmp/")
+        ssh3(ip,"cd /tmp/ && gunzip postgres.gz && gunzip mysql.gz")
+        ssh3(ip,"PGPASSWORD=bitnami psql -U postgres -f /tmp/postgres")
+        ssh3(ip,"mysql -uroot -pbitnami < /tmp/mysql")
+        ssh3(ip,"sudo rm -f /tmp/mysql /tmp/postgres")
+
+        ssh2(ip,"sudo mkdir /opt/bitnami/nginx/keys/; ")
+        puts `scp -i ~/crypto/meroku/meroku.id_rsa ~/crypto/meroku/meroku_site_fullchain.pem ubuntu@#{ip}:/home/bitnami/`
+        ssh2(ip, 'sudo mv ~/meroku_site_fullchain.pem /opt/bitnami/nginx/keys/; ')
+        puts `scp -i ~/crypto/meroku/meroku.id_rsa ~/crypto/meroku/meroku_site_privkey.pem ubuntu@#{ip}:/home/bitnami/`
+        ssh2(ip,'sudo mv ~/meroku_site_privkey.pem /opt/bitnami/nginx/keys/; ')
+
+        ssh2(ip,"sudo cp meroku/misc/gemrc /etc/gemrc")
+        ssh2(ip,"cd meroku/rails_app; NOKOGIRI_USE_SYSTEM_LIBRARIES=1 bundle install")
+
+        ssh3(ip,"cd meroku/rails_app; RAILS_ENV=production rake nginx:rebuild")
+
+        # create unix users
+        ssh3(ip,"cd meroku/rails_app; RAILS_ENV=production rake unix_users:rebuild")
+        # create unix users directories
+        ssh3(ip,"#{aws_exports} aws s3 cp s3://meroku-database-backups/home_dirs.gz /tmp/")
+        ssh3(ip,"#{aws_exports} cd /; sudo tar xzvf /tmp/home_dirs.gz")
+        ssh3(ip,"sudo rm -f /tmp/home_dirs.gz")
+
+        ssh3(ip,"cd meroku/rails_app; SECRET_KEY_BASE=fixme rake assets:precompile")
+        ssh3(ip,"cd meroku/rails_app; RAILS_SERVE_STATIC_FILES=1 SECRET_KEY_BASE=fixme rails s -e production -d -b 0.0.0.0 && sleep 5")
+
+        # start customer rails apps here wipwip
+
+        ssh3(ip,"sudo /opt/bitnami/ctlscript.sh stop apache")
+        ssh3(ip,"sudo /opt/bitnami/ctlscript.sh restart nginx")
+        ssh3(ip,"sudo ls -la /opt/bitnami/nginx/conf/vhosts/")
+      end
+
+      desc "start", "spins up an ubuntu server"
+      long_desc <<-LONGDESC
+        Spins up an ubuntu server with name tag "meroku",
+        with the production ip not yet assigned
+      LONGDESC
+      def start()
+        admin_secrets_required
+        terminate_unused_servers
+        instance_id = ec2_start_instance
+        ec2_tag_instance(instance_id)
+        ec2_await_boot(instance_id)
+      end
+    end
+  end
+end

data/lib/meroku/cli/server.rb~

@@ -0,0 +1,4 @@
+module Meroku
+  module CLI
+    require 'action_view'
+    include ActionView::Helpers::TextHelper

data/lib/meroku/cli.rb

@@ -0,0 +1,8 @@
+require 'thor'
+module Meroku
+
+  module CLI
+    
+  end
+
+end

data/lib/meroku/config.rb

@@ -0,0 +1,6 @@
+module Meroku
+  class Config < ApplicationRecord
+    belongs_to :app, class_name: "Meroku::App"
+    
+  end
+end

data/lib/meroku/configs_controller.rb

@@ -0,0 +1,62 @@
+
+module Meroku
+  
+  class ConfigsController < ApplicationController
+    skip_before_action :verify_authenticity_token, only: [:create, :destroy]
+    before_action :authenticate, only: [ :create, :index, :destroy ]
+
+    def index
+      configs = Meroku::App.last.configs.map { |x| "#{x.name}: #{x.value || 'nil'}" }.join("\n")
+      render json: {
+        "data": "#{configs}\n"
+      }
+    end  
+
+    def create
+      @config = Meroku::Config.where(name: params["name"], app_id: @app_.id).try(:first)
+      if @config
+        # if variable exists, update its value
+        @config.update_attributes(value: params["value"])
+      else      
+        # if it doesn't exist, create record      
+        @config = Meroku::Config.new(
+          name: params["name"],
+          value: params["value"],
+          app_id: @app_.id
+        )
+      end
+      respond_to do |format|
+        if @config.save
+          format.json { render json: {  data: @config  } }
+        else
+          format.json { render json: { :errors => @config.errors }, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    ## PATCH/PUT /keys/1
+    ## PATCH/PUT /keys/1.json
+    #def update
+    #  respond_to do |format|
+    #    if @key.update(key_params)
+    #      format.html { redirect_to @key, notice: 'Key was successfully updated.' }
+    #      format.json { render :show, status: :ok, location: @key }
+    #    else
+    #      format.html { render :edit }
+    #      format.json { render json: @key.errors, status: :unprocessable_entity }
+    #    end
+    #  end
+    #end
+
+    # DELETE /keys/1
+    # DELETE /keys/1.json
+    def destroy
+      @config = Meroku::Config.find_by_name(params["name"])
+      @config.destroy
+      respond_to do |format|
+        format.json { render json: {  data: @config  } }
+      end
+    end
+  
+  end
+end

data/lib/meroku/core_ext.rb

@@ -0,0 +1,30 @@
+class Array
+  # File activesupport/lib/active_support/core_ext/array/conversions.rb, line 59
+  def to_sentence(options = {})
+    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
+  
+    default_connectors = {
+      :words_connector     => ', ',
+      :two_words_connector => ' and ',
+      :last_word_connector => ', and '
+    }
+    if defined?(I18n)
+      i18n_connectors = I18n.translate(:'support.array', locale: options[:locale], default: {})
+      default_connectors.merge!(i18n_connectors)
+    end
+    options = default_connectors.merge!(options)
+  
+    case length
+    when 0
+      ''
+    when 1
+      self[0].to_s.dup
+    when 2
+      "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+    else
+      "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+    end
+  end
+end
+
+  

data/lib/meroku/domain.rb

@@ -0,0 +1,6 @@
+module Meroku
+  class Domain < ApplicationRecord
+    belongs_to :app, class_name: "Meroku::App"
+    validates_uniqueness_of :domain
+  end
+end

data/lib/meroku/domains_controller.rb

@@ -0,0 +1,83 @@
+
+module Meroku
+  
+  class DomainsController < ApplicationController
+    #before_action :set_domain, only: [:show, :edit, :update, :destroy]
+    skip_before_action :verify_authenticity_token, only: [:create, :destroy]
+    before_action :authenticate, only: [ :create, :index, :destroy ]
+
+    ## GET /keys
+    ## GET /keys.json
+    def index
+      @domain_names = @app_.domains.pluck(:domain)
+      render json: { "data": @domain_names  }
+    end
+  
+    ## GET /keys/1
+    ## GET /keys/1.json
+    #def show
+    #end
+    #
+    ## GET /keys/new
+    #def new
+    #  @key = Key.new
+    #end
+    #
+    ## GET /keys/1/edit
+    #def edit
+    #end
+    #
+    # POST /keys
+    # POST /keys.json
+    def create
+      @domain = Meroku::Domain.new(
+        domain: params["domain"],
+        app_id: @app_.id
+      )
+      respond_to do |format|
+        if @domain.save
+          Meroku::Util.nginx_rebuild()
+          format.json { render json: {  data: @domain  } }
+        else
+          format.json { render json: { :errors => @domain.errors }, status: :unprocessable_entity }
+        end
+      end
+    end
+    #
+    ## PATCH/PUT /keys/1
+    ## PATCH/PUT /keys/1.json
+    #def update
+    #  respond_to do |format|
+    #    if @key.update(key_params)
+    #      format.html { redirect_to @key, notice: 'Key was successfully updated.' }
+    #      format.json { render :show, status: :ok, location: @key }
+    #    else
+    #      format.html { render :edit }
+    #      format.json { render json: @key.errors, status: :unprocessable_entity }
+    #    end
+    #  end
+    #end
+
+    # DELETE /keys/1
+    # DELETE /keys/1.json
+    def destroy
+      @domain = Meroku::Domain.find_by_domain(params["domain"])
+      @domain.destroy
+      Meroku::Util.nginx_rebuild()
+      respond_to do |format|
+        format.json { render json: {  data: @domain  } }
+      end
+    end
+  
+    private
+      ## Use callbacks to share common setup or constraints between actions.
+      #def set_key
+      #  @key = Key.find(params[:id])
+      #end
+      #
+      ## Never trust parameters from the scary internet, only allow the white list through.
+      #def key_params
+      #  params.require(:key).permit(:key, :original_filename, :user_id)
+      #end
+  end
+end

data/lib/meroku/error.rb

@@ -0,0 +1,6 @@
+module Meroku
+  module Error
+
+  end
+  
+end

data/lib/meroku/key.rb

@@ -0,0 +1,11 @@
+module Meroku
+  
+  class Key < Meroku::ApplicationRecord
+    include Meroku::Util
+
+    belongs_to :user
+
+    after_create :update_authorized_keys_file
+  end
+
+end

data/lib/meroku/keys_controller.rb

@@ -0,0 +1,82 @@
+
+module Meroku
+  
+  class KeysController < ApplicationController
+    before_action :set_key, only: [:show, :edit, :update, :destroy]
+    skip_before_action :verify_authenticity_token, only: [:create]
+    before_action :authenticate, only: [ :create ]
+
+    ## GET /keys
+    ## GET /keys.json
+    #def index
+    #  @keys = Meroku::Key.allxb
+    #  render json: { "data": @keys }
+    #end
+  
+    ## GET /keys/1
+    ## GET /keys/1.json
+    #def show
+    #end
+    #
+    ## GET /keys/new
+    #def new
+    #  @key = Key.new
+    #end
+    #
+    ## GET /keys/1/edit
+    #def edit
+    #end
+    #
+    # POST /keys
+    # POST /keys.json
+    def create
+      @key = Meroku::Key.new(
+        key: params["key"],
+        user_id: @user.id
+      )
+      respond_to do |format|
+        if @key.save
+          format.json { render json: {  data: @key  } }
+        else
+         
+          format.json { render json: { :errors => @key.errors }, status: :unprocessable_entity }
+        end
+      end
+    end
+    #
+    ## PATCH/PUT /keys/1
+    ## PATCH/PUT /keys/1.json
+    #def update
+    #  respond_to do |format|
+    #    if @key.update(key_params)
+    #      format.html { redirect_to @key, notice: 'Key was successfully updated.' }
+    #      format.json { render :show, status: :ok, location: @key }
+    #    else
+    #      format.html { render :edit }
+    #      format.json { render json: @key.errors, status: :unprocessable_entity }
+    #    end
+    #  end
+    #end
+    #
+    ## DELETE /keys/1
+    ## DELETE /keys/1.json
+    #def destroy
+    #  @key.destroy
+    #  respond_to do |format|
+    #    format.html { redirect_to keys_url, notice: 'Key was successfully destroyed.' }
+    #    format.json { head :no_content }
+    #  end
+    #end
+  
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_key
+        @key = Key.find(params[:id])
+      end
+  
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def key_params
+        params.require(:key).permit(:key, :original_filename, :user_id)
+      end
+  end
+end

data/lib/meroku/sanitychecks.rb

@@ -0,0 +1,19 @@
+module Meroku
+  module Sanitychecks
+
+    def admin_secrets_required
+      secrets_dir = "#{Dir.home}/crypto/meroku/"
+      IO.read("#{secrets_dir}/meroku_secrets")
+      require 'dotenv'
+      Dotenv.load("#{secrets_dir}/meroku_secrets")
+      IO.read("#{secrets_dir}/meroku.id_rsa")
+      #IO.read("#{secrets_dir}/meroku.id_rsa.pub")
+      #IO.read("#{secrets_dir}/meroku_site_cert.pem")
+      #IO.read("#{secrets_dir}/meroku_site_chain.pem")
+      #IO.read("#{secrets_dir}/meroku_site_fullchain.pem")
+      #IO.read("#{secrets_dir}/meroku_site_privkey.pem")
+      #IO.read("#{secrets_dir}/meroku_ssh_host_keys.tgz")
+    end
+    
+  end
+end

data/lib/meroku/user.rb

@@ -0,0 +1,23 @@
+module Meroku
+  
+  class User < Meroku::ApplicationRecord
+    include Meroku::Util
+
+    # Include default devise modules. Others available are:
+    # :confirmable, :lockable, :timeoutable and :omniauthable
+    devise :database_authenticatable, :registerable,
+           :recoverable, :rememberable, :trackable, :validatable
+
+    has_many :keys
+    
+    after_create :add_unix_user
+    after_create :install_rvm_for_user
+
+    def database_password
+      encrypted_password[7..20].gsub(/[^0-9a-z ]/i, '')
+    end
+    
+  end
+
+end
+