invoker 1.4.1 → 1.5.1

data/spec/invoker/config_spec.rb

@@ -134,59 +134,53 @@ command = ls
     end
   end
 
-  describe "loading power config" do
+  describe "loading power config", fakefs: true do
     before do
-      @file = Tempfile.new(["config", ".ini"])
+      FileUtils.mkdir_p('/tmp')
+      FileUtils.mkdir_p(inv_conf_dir)
+      File.open("/tmp/foo.ini", "w") { |fl| fl.write("") }
     end
 
     it "does not load config if platform is darwin but there is no power config file" do
       Invoker::Power::Config.expects(:load_config).never
-      Invoker::Parsers::Config.new(@file.path, 9000)
+      Invoker::Parsers::Config.new("/tmp/foo.ini", 9000)
     end
 
     it "loads config if platform is darwin and power config file exists" do
       File.open(Invoker::Power::Config.config_file, "w") { |fl| fl.puts "sample" }
       Invoker::Power::Config.expects(:load_config).once
-      Invoker::Parsers::Config.new(@file.path, 9000)
+      Invoker::Parsers::Config.new("/tmp/foo.ini", 9000)
     end
   end
 
   describe "Procfile" do
     it "should load Procfiles and create config object" do
-      begin
-        File.open("/tmp/Procfile", "w") {|fl| 
-          fl.write <<-EOD
+      File.open("/tmp/Procfile", "w") {|fl| 
+        fl.write <<-EOD
 web: bundle exec rails s -p $PORT
           EOD
-        }
-        config = Invoker::Parsers::Config.new("/tmp/Procfile", 9000)
-        command1 = config.processes.first
+      }
+      config = Invoker::Parsers::Config.new("/tmp/Procfile", 9000)
+      command1 = config.processes.first
 
-        expect(command1.port).to eq(9000)
-        expect(command1.cmd).to match(/bundle exec rails/)
-      ensure
-        File.delete("/tmp/Procfile")
-      end
+      expect(command1.port).to eq(9000)
+      expect(command1.cmd).to match(/bundle exec rails/)
     end
   end
 
   describe "Copy of DNS information" do
     it "should allow copy of DNS information" do
-      begin
-        File.open("/tmp/Procfile", "w") {|fl| 
-          fl.write <<-EOD
+      File.open("/tmp/Procfile", "w") {|fl| 
+        fl.write <<-EOD
 web: bundle exec rails s -p $PORT
           EOD
-        }
-        Invoker.load_invoker_config("/tmp/Procfile", 9000)
-        dns_cache = Invoker::DNSCache.new(Invoker.config)
+      }
+      Invoker.load_invoker_config("/tmp/Procfile", 9000)
+      dns_cache = Invoker::DNSCache.new(Invoker.config)
 
-        expect(dns_cache.dns_data).to_not be_empty
-        expect(dns_cache.dns_data['web']).to_not be_empty
-        expect(dns_cache.dns_data['web']['port']).to eql 9000
-      ensure
-        File.delete("/tmp/Procfile")
-      end
+      expect(dns_cache.dns_data).to_not be_empty
+      expect(dns_cache.dns_data['web']).to_not be_empty
+      expect(dns_cache.dns_data['web']['port']).to eql 9000
     end
   end
 
@@ -227,6 +221,7 @@ command = bundle exec rails s -p $PORT
   describe "global config file" do
     it "should use global config file if available" do
       begin
+        FileUtils.mkdir_p(Invoker::Power::Config.config_dir)
         filename = "#{Invoker::Power::Config.config_dir}/foo.ini"
         file = File.open(filename, "w")
         config_data =<<-EOD

data/spec/invoker/invoker_spec.rb

@@ -13,7 +13,8 @@ describe "Invoker" do
     end
   end
 
-  describe "#can_run_balancer?" do
+  describe "#can_run_balancer?", fakefs: true do
+    before { FileUtils.mkdir_p(Invoker::Power::Config.config_dir) }
     it "should return false if setup command was not run" do
       expect(Invoker.can_run_balancer?).to be_falsey
     end

data/spec/invoker/ipc/client_handler_spec.rb

@@ -35,7 +35,17 @@ describe Invoker::IPC::ClientHandler do
   describe "add_http command" do
     let(:message_object) { MM::AddHttp.new(process_name: 'foo', port: 9000)}
     it "adds the process name and port to dns cache" do
-      invoker_dns_cache.expects(:add).with('foo', 9000)
+      invoker_dns_cache.expects(:add).with('foo', 9000, nil)
+      client_socket.string = message_object.encoded_message
+
+     client.read_and_execute
+    end
+  end
+
+  describe "add_http command with optional ip" do
+    let(:message_object) { MM::AddHttp.new(process_name: 'foo', port: 9000, ip: '192.168.0.1')}
+    it "adds the process name, port and host ip to dns cache" do
+      invoker_dns_cache.expects(:add).with('foo', 9000, '192.168.0.1')
       client_socket.string = message_object.encoded_message
 
      client.read_and_execute

data/spec/invoker/power/config_spec.rb

@@ -1,8 +1,9 @@
 require "spec_helper"
 
-describe "Invoker Power configuration" do
+describe "Invoker Power configuration", fakefs: true do
   describe "#create" do
     it "should create a config file given a hash" do
+      FileUtils.mkdir_p(inv_conf_dir)
       config = Invoker::Power::Config.create(
         dns_port: 1200, http_port: 1201, ipfw_rule_number: 010
       )

data/spec/invoker/power/pf_migrate_spec.rb

@@ -2,6 +2,7 @@ require "spec_helper"
 
 describe Invoker::Power::PfMigrate do
   before do
+    FileUtils.mkdir_p("/tmp/.invoker")
     @old_firewall_file = Invoker::Power::OsxSetup::FIREWALL_PLIST_FILE
     Invoker::Power::OsxSetup.const_set(:FIREWALL_PLIST_FILE, "/tmp/.invoker/firewall")
   end
@@ -54,12 +55,18 @@ describe Invoker::Power::PfMigrate do
 
   describe "#migrate" do
     before do
+      @original_invoker_config = Invoker.config
       mock_config = mock()
       mock_config.stubs(:http_port).returns(80)
       mock_config.stubs(:https_port).returns(443)
+      mock_config.stubs(:tld).returns('dev')
       Invoker.config = mock_config
     end
 
+    after do
+      Invoker.config = @original_invoker_config
+    end
+
     it "should migrate firewall to new system" do
       pf_migrator.expects(:firewall_config_requires_migration?).returns(true)
       pf_migrator.expects(:ask_user_for_migration).returns(true)

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

@@ -1,9 +1,31 @@
 require "spec_helper"
 require "invoker/power/setup/distro/ubuntu"
+require "invoker/power/setup/distro/opensuse"
 
-describe Invoker::Power::LinuxSetup do
-  let(:invoker_setup) { Invoker::Power::LinuxSetup.new }
-  let(:distro_installer) { Invoker::Power::Distro::Ubuntu.new }
+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 }
@@ -27,8 +49,20 @@ describe Invoker::Power::LinuxSetup do
     end
   end
 
-  describe "configuring dnsmasq and rinetd" do
-    before { invoker_setup.distro_installer = distro_installer }
+  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)
@@ -46,10 +80,24 @@ describe Invoker::Power::LinuxSetup do
       expect(dnsmasq_content.strip).to_not be_empty
       expect(dnsmasq_content).to match(/dev/)
 
-      rinetd_content = File.read(distro_installer.rinetd_file)
-      expect(rinetd_content.strip).to_not be_empty
-      expect(rinetd_content.strip).to match(/#{config.https_port}/)
-      expect(rinetd_content.strip).to match(/#{config.http_port}/)
+      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

@@ -1,9 +1,14 @@
 require "spec_helper"
 
-describe Invoker::Power::OsxSetup do
-  describe "When no setup exists" do
+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
+      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
@@ -23,16 +28,16 @@ describe Invoker::Power::OsxSetup do
         fl.write("foo test")
       }
       Invoker::Power::Setup.any_instance.expects(:setup_invoker).never
-      Invoker::Power::Setup.install()
+      Invoker::Power::Setup.install('dev')
     end
   end
 
   describe "when pow like setup exists" do
     before {
-      File.open(Invoker::Power::OsxSetup::RESOLVER_FILE, "w") {|fl|
+      File.open(File.join(Invoker::Power::OsxSetup::RESOLVER_DIR, "dev"), "w") { |fl|
         fl.write("hello")
       }
-      @setup = Invoker::Power::OsxSetup.new
+      @setup = Invoker::Power::OsxSetup.new('dev')
     }
 
     describe "when user selects to overwrite it" do
@@ -60,7 +65,7 @@ describe Invoker::Power::OsxSetup do
 
   describe "uninstalling firewall rules" do
     it "should uninstall firewall rules and remove all files created by setup" do
-      setup = Invoker::Power::OsxSetup.new
+      setup = Invoker::Power::OsxSetup.new('dev')
 
       Invoker::CLI::Question.expects(:agree).returns(true)
       setup.expects(:remove_resolver_file).once
@@ -74,7 +79,7 @@ describe Invoker::Power::OsxSetup do
   describe "setup on fresh osx install" do
     context "when resolver directory does not exist" do
       before do
-        @setup = Invoker::Power::OsxSetup.new
+        @setup = Invoker::Power::OsxSetup.new('dev')
         FileUtils.rm_rf(Invoker::Power::OsxSetup::RESOLVER_DIR)
       end
 
@@ -88,4 +93,13 @@ describe Invoker::Power::OsxSetup do
       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/url_rewriter_spec.rb

@@ -4,7 +4,18 @@ describe Invoker::Power::UrlRewriter do
   let(:rewriter) { Invoker::Power::UrlRewriter.new }
 
   context "matching domain part of incoming request" do
-    it "should do foo.dev match" 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
 
@@ -34,5 +45,26 @@ describe Invoker::Power::UrlRewriter do
 
       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

@@ -2,13 +2,19 @@ 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
-      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"))
+      @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
@@ -94,5 +100,31 @@ BAR=foo
       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