meepo 1.5.2

data/spec/invoker/power/port_finder_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe "PortFinder" do
+  before do
+    @port_finder = Invoker::Power::PortFinder.new()
+    @port_finder.find_ports
+  end
+
+  it "should find a http port" do
+    expect(@port_finder.http_port).not_to be_nil
+  end
+
+  it "should find a dns port" do
+    expect(@port_finder.dns_port).not_to be_nil
+  end
+end

data/spec/invoker/power/setup/linux_setup_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+require "invoker/power/setup/distro/ubuntu"
+require "invoker/power/setup/distro/opensuse"
+
+def mock_socat_scripts
+  FakeFS.deactivate!
+  socat_content = File.read(invoker_setup.forwarder_script)
+  socat_systemd = File.read(invoker_setup.socat_unit)
+  FakeFS.activate!
+  FileUtils.mkdir_p(File.dirname(invoker_setup.forwarder_script))
+  FileUtils.mkdir_p(File.dirname(invoker_setup.socat_unit))
+  File.open(invoker_setup.socat_unit, "w") do |fl|
+    fl.write(socat_systemd)
+  end
+  File.open(invoker_setup.forwarder_script, "w") do |fl|
+    fl.write(socat_content)
+  end
+  FileUtils.mkdir_p("/usr/bin")
+end
+
+describe Invoker::Power::LinuxSetup, fakefs: true do
+  before do
+    FileUtils.mkdir_p(inv_conf_dir)
+    FileUtils.mkdir_p(Invoker::Power::Distro::Base::RESOLVER_DIR)
+  end
+
+  let(:invoker_setup) { Invoker::Power::LinuxSetup.new('dev') }
+  let(:distro_installer) { Invoker::Power::Distro::Ubuntu.new('dev') }
+
+  describe "should only proceed after user confirmation" do
+    before { invoker_setup.distro_installer = distro_installer }
+
+    it "should create config file with port" do
+      invoker_setup.expects(:initialize_distro_installer).returns(true)
+      invoker_setup.expects(:get_user_confirmation?).returns(true)
+      invoker_setup.expects(:install_resolver).returns(true)
+      invoker_setup.expects(:install_port_forwarder).returns(true)
+      invoker_setup.expects(:drop_to_normal_user).returns(true)
+
+      distro_installer.expects(:install_required_software)
+      distro_installer.expects(:restart_services)
+
+      invoker_setup.setup_invoker
+
+      config = Invoker::Power::Config.load_config
+      expect(config.http_port).not_to be_nil
+      expect(config.dns_port).to be_nil
+      expect(config.https_port).not_to be_nil
+    end
+  end
+
+  describe "configuring dnsmasq and socat" do
+    before(:all) do
+      @original_invoker_config = Invoker.config
+      Invoker.config = mock
+    end
+
+    after(:all) do
+      Invoker.config = @original_invoker_config
+    end
+
+    before(:each) do
+      invoker_setup.distro_installer = distro_installer
+      mock_socat_scripts
+    end
+
+    it "should create proper config file" do
+      invoker_setup.expects(:initialize_distro_installer).returns(true)
+      invoker_setup.expects(:get_user_confirmation?).returns(true)
+      invoker_setup.expects(:drop_to_normal_user).returns(true)
+
+      distro_installer.expects(:install_required_software)
+      distro_installer.expects(:restart_services)
+
+      invoker_setup.setup_invoker
+
+      config = Invoker::Power::Config.load_config
+
+      dnsmasq_content = File.read(distro_installer.resolver_file)
+      expect(dnsmasq_content.strip).to_not be_empty
+      expect(dnsmasq_content).to match(/dev/)
+
+      socat_content = File.read(Invoker::Power::Distro::Base::SOCAT_SHELLSCRIPT)
+      expect(socat_content.strip).to_not be_empty
+      expect(socat_content.strip).to match(/#{config.https_port}/)
+      expect(socat_content.strip).to match(/#{config.http_port}/)
+
+      service_file = File.read(Invoker::Power::Distro::Base::SOCAT_SYSTEMD)
+      expect(service_file.strip).to_not be_empty
+    end
+  end
+
+  describe 'resolver file' do
+    context 'user sets up a custom top level domain' do
+      it 'should create the correct resolver file' do
+        linux_setup = Invoker::Power::LinuxSetup.new('local')
+        suse_installer = Invoker::Power::Distro::Opensuse.new('local')
+        linux_setup.distro_installer = suse_installer
+        expect(linux_setup.resolver_file).to eq('/etc/dnsmasq.d/local-tld')
+      end
+    end
+  end
+end

data/spec/invoker/power/setup/osx_setup_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+describe Invoker::Power::OsxSetup, fakefs: true do
+  before do
+    FileUtils.mkdir_p(inv_conf_dir)
+    FileUtils.mkdir_p(Invoker::Power::OsxSetup::RESOLVER_DIR)
+  end
+
+  describe "when no setup exists" do
+    it "should create a config file with port etc" do
+      setup = Invoker::Power::OsxSetup.new('dev')
+      setup.expects(:install_resolver).returns(true)
+      setup.expects(:drop_to_normal_user).returns(true)
+      setup.expects(:install_firewall).once
+
+      setup.setup_invoker
+
+      config = Invoker::Power::Config.load_config
+      expect(config.http_port).not_to be_nil
+      expect(config.dns_port).not_to be_nil
+      expect(config.https_port).not_to be_nil
+    end
+  end
+
+  describe "when a setup file exists" do
+    it "should throw error about existing file" do
+      File.open(Invoker::Power::Config.config_file, "w") {|fl|
+        fl.write("foo test")
+      }
+      Invoker::Power::Setup.any_instance.expects(:setup_invoker).never
+      Invoker::Power::Setup.install('dev')
+    end
+  end
+
+  describe "when pow like setup exists" do
+    before {
+      File.open(File.join(Invoker::Power::OsxSetup::RESOLVER_DIR, "dev"), "w") { |fl|
+        fl.write("hello")
+      }
+      @setup = Invoker::Power::OsxSetup.new('dev')
+    }
+
+    describe "when user selects to overwrite it" do
+      it "should run setup normally" do
+        @setup.expects(:setup_resolver_file).returns(true)
+        @setup.expects(:drop_to_normal_user).returns(true)
+        @setup.expects(:install_resolver).returns(true)
+        @setup.expects(:install_firewall).once()
+
+        @setup.setup_invoker
+      end
+    end
+
+    describe "when user chose not to overwrite it" do
+      it "should abort the setup process" do
+        @setup.expects(:setup_resolver_file).returns(false)
+
+        @setup.expects(:install_resolver).never
+        @setup.expects(:install_firewall).never
+
+        @setup.setup_invoker
+      end
+    end
+  end
+
+  describe "uninstalling firewall rules" do
+    it "should uninstall firewall rules and remove all files created by setup" do
+      setup = Invoker::Power::OsxSetup.new('dev')
+
+      Invoker::CLI::Question.expects(:agree).returns(true)
+      setup.expects(:remove_resolver_file).once
+      setup.expects(:unload_firewall_rule).with(true).once
+      Invoker::Power::Config.expects(:delete).once
+
+      setup.uninstall_invoker
+    end
+  end
+
+  describe "setup on fresh osx install" do
+    context "when resolver directory does not exist" do
+      before do
+        @setup = Invoker::Power::OsxSetup.new('dev')
+        FileUtils.rm_rf(Invoker::Power::OsxSetup::RESOLVER_DIR)
+      end
+
+      it "should create the directory and install" do
+        @setup.expects(:setup_resolver_file).returns(true)
+        @setup.expects(:drop_to_normal_user).returns(true)
+        @setup.expects(:install_firewall).once()
+
+        @setup.setup_invoker
+        expect(Dir.exist?(Invoker::Power::OsxSetup::RESOLVER_DIR)).to be_truthy
+      end
+    end
+  end
+
+  describe '.resolver_file' do
+    context 'user sets up a custom top level domain' do
+      it 'should create the correct resolver file' do
+        setup = Invoker::Power::OsxSetup.new('local')
+        expect(setup.resolver_file).to eq('/etc/resolver/local')
+      end
+    end
+  end
+end

data/spec/invoker/power/setup_spec.rb

@@ -0,0 +1,4 @@
+require "spec_helper"
+
+describe "Setup" do
+end

data/spec/invoker/power/url_rewriter_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Invoker::Power::UrlRewriter do
+  let(:rewriter) { Invoker::Power::UrlRewriter.new }
+
+  context "matching domain part of incoming request" do
+    before(:all) do
+      @original_invoker_config = Invoker.config
+
+      Invoker.config = mock
+      Invoker.config.stubs(:tld).returns("dev")
+    end
+
+    after(:all) do
+      Invoker.config = @original_invoker_config
+    end
+
+    it "should match foo.dev" do
+      match = rewriter.extract_host_from_domain("foo.dev")
+      expect(match).to_not be_empty
+
+      matching_string = match[0]
+      expect(matching_string).to eq("foo")
+    end
+
+    it "should match foo.dev:1080" do
+      match = rewriter.extract_host_from_domain("foo.dev:1080")
+      expect(match).to_not be_empty
+
+      matching_string = match[0]
+      expect(matching_string).to eq("foo")
+    end
+
+    it "should match emacs.bar.dev" do
+      match = rewriter.extract_host_from_domain("emacs.bar.dev")
+      expect(match).to_not be_empty
+
+      expect(match[0]).to eq("emacs.bar")
+      expect(match[1]).to eq("bar")
+    end
+
+    it "should match hello-world.dev" do
+      match = rewriter.extract_host_from_domain("hello-world.dev")
+      expect(match).to_not be_nil
+
+      expect(match[0]).to eq("hello-world")
+    end
+
+    context 'user sets up a custom top level domain' do
+      before(:all) do
+        @original_invoker_config = Invoker.config
+
+        Invoker.config = mock
+        Invoker.config.stubs(:tld).returns("local")
+      end
+
+      it 'should match domain part of incoming request correctly' do
+        match = rewriter.extract_host_from_domain("foo.local")
+        expect(match).to_not be_empty
+
+        matching_string = match[0]
+        expect(matching_string).to eq("foo")
+      end
+
+      after(:all) do
+        Invoker.config = @original_invoker_config
+      end
+    end
+  end
+end

data/spec/invoker/power/web_sockets_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+# Full integration test. Start a server, and client. Let client interact with
+# server do a ping-pong. Client checks whether ping pong is successful or not.
+# Also, mock rewriter so that it returns valid port for request proxying.
+# - Server will run on port 28080.
+# - Balancer will run on port 28081 proxying to 28080
+# - Client will connect to 28081 performing ping-pong
+
+def websocket_server
+  require 'websocket-eventmachine-server'
+
+  EM.run do
+    WebSocket::EventMachine::Server.start(host: "0.0.0.0", port: 28080) do |ws|
+      ws.onerror { |e| p e }
+      ws.onmessage { ws.send "pong" }
+    end
+
+    EM.add_timer(2) { EM.stop }
+  end
+end
+
+def websocket_client
+  require 'websocket-eventmachine-client'
+
+  @message = ""
+
+  EM.run do
+    ws = WebSocket::EventMachine::Client.connect(uri: 'ws://0.0.0.0:28081')
+    ws.onerror { |e| p e }
+    ws.onopen { ws.send("ping") }
+    ws.onmessage { |m, _| @message = m }
+
+    EM.add_timer(2) do
+      expect(@message).to eq "pong"
+      EM.stop
+    end
+  end
+end
+
+
+describe 'Web sockets support' do
+  it 'can ping pong via balancer' do
+    dns_response = Struct.new(:port, :ip).new(28080, "0.0.0.0")
+    Invoker::Power::UrlRewriter.any_instance
+      .stubs(:select_backend_config)
+      .returns(dns_response)
+
+    EM.run do
+      EM.start_server("0.0.0.0", 28081, EM::ProxyServer::Connection, {}) do |conn|
+        Invoker::Power::Balancer.new(conn, "http").install_callbacks
+      end
+
+      fork { websocket_server }
+      fork { websocket_client }
+      EM.add_timer(3) { EM.stop }
+    end
+
+    Process.waitall
+  end
+end

data/spec/invoker/process_manager_spec.rb

@@ -0,0 +1,130 @@
+require "spec_helper"
+
+describe Invoker::ProcessManager do
+  let(:process_manager) { Invoker::ProcessManager.new }
+
+  describe "#start_process_by_name" do
+    it "should find command by label and start it, if found" do
+      @original_invoker_config = Invoker.config
+      Invoker.config = mock
+
+      Invoker.config.stubs(:processes).returns([OpenStruct.new(:label => "resque", :cmd => "foo", :dir => "bar")])
+      Invoker.config.expects(:process).returns(OpenStruct.new(:label => "resque", :cmd => "foo", :dir => "bar"))
+      process_manager.expects(:start_process).returns(true)
+
+      process_manager.start_process_by_name("resque")
+
+      Invoker.config = @original_invoker_config
+    end
+
+    it "should not start already running process" do
+      process_manager.workers.expects(:[]).returns(OpenStruct.new(:pid => "bogus"))
+      expect(process_manager.start_process_by_name("resque")).to be_falsey
+    end
+  end
+
+  describe "#stop_process" do
+    let(:message) { MM::Remove.new(options) }
+    describe "when a worker is found" do
+      before do
+        process_manager.workers.expects(:[]).returns(OpenStruct.new(:pid => "bogus"))
+      end
+
+      describe "if a signal is specified" do
+        let(:options) { { process_name: 'bogus', signal: 'HUP' } }
+        it "should use that signal to kill the worker" do
+          process_manager.expects(:process_kill).with("bogus", "HUP").returns(true)
+          expect(process_manager.stop_process(message)).to be_truthy
+        end
+      end
+
+      describe "if no signal is specified" do
+        let(:options) { { process_name: 'bogus' } }
+        it "should use INT signal" do
+          process_manager.expects(:process_kill).with("bogus", "INT").returns(true)
+          expect(process_manager.stop_process(message)).to be_truthy
+        end
+      end
+    end
+
+    describe "when no worker is found" do
+      let(:options) { { process_name: 'bogus', signal: 'HUP' } }
+      before do
+        process_manager.workers.expects(:[]).returns(nil)
+      end
+
+      it "should not kill anything" do
+        process_manager.expects(:process_kill).never
+        process_manager.stop_process(message)
+      end
+    end
+  end
+
+  describe "#load_env" do
+    it "should load .env file from the specified directory" do
+      dir = "/tmp"
+      begin
+        env_file = File.new("#{dir}/.env", "w")
+        env_data =<<-EOD
+FOO=foo
+BAR=bar
+        EOD
+        env_file.write(env_data)
+        env_file.close
+        env_options = process_manager.load_env(dir)
+        expect(env_options).to include("FOO" => "foo", "BAR" => "bar")
+      ensure
+        File.delete(env_file.path)
+      end
+    end
+
+    it "should default to current directory if no directory is specified" do
+      dir = ENV["HOME"]
+      ENV.stubs(:[]).with("PWD").returns(dir)
+      begin
+        env_file = File.new("#{dir}/.env", "w")
+        env_data =<<-EOD
+FOO=bar
+BAR=foo
+        EOD
+        env_file.write(env_data)
+        env_file.close
+        env_options = process_manager.load_env
+        expect(env_options).to include("FOO" => "bar", "BAR" => "foo")
+      ensure
+        File.delete(env_file.path)
+      end
+    end
+
+    it "should return empty hash if there is no .env file" do
+      dir = "/tmp"
+      expect(process_manager.load_env(dir)).to eq({})
+    end
+
+    it "should load .local.env file if it exists" do
+      dir = "/tmp"
+      begin
+        env_file = File.new("#{dir}/.env", "w")
+        env_data =<<-EOD
+FOO=foo
+BAR=bar
+        EOD
+        env_file.write(env_data)
+        env_file.close
+
+        local_env_file = File.new("#{dir}/.env.local", "w")
+        local_env_data =<<-EOD
+FOO=emacs
+        EOD
+        local_env_file.write(local_env_data)
+        local_env_file.close
+
+        env_options = process_manager.load_env(dir)
+        expect(env_options).to include("FOO" => "emacs", "BAR" => "bar")
+      ensure
+        File.delete(env_file.path)
+        File.delete(local_env_file.path)
+      end
+    end
+  end
+end