tools-cf-plugin 1.0.0 → 1.1.0

data/spec/tunnel/base_spec.rb

@@ -0,0 +1,180 @@
+require "spec_helper"
+
+module CFTools::Tunnel
+  describe Base do
+    before do
+      stub(subject).input { { :quiet => true } }
+    end
+
+    describe "#director" do
+      context "when the given director is accessible" do
+        before do
+          stub(subject).address_reachable?("some-director.com", 25555) { true }
+        end
+
+        it "returns the given director" do
+          director = subject.director("some-director.com", nil)
+          expect(director.director_uri.host).to eq("some-director.com")
+          expect(director.director_uri.port).to eq(25555)
+        end
+      end
+
+      context "when the given director is inaccessible" do
+        before do
+          stub(subject).address_reachable?("some-director.com", 25555) { false }
+        end
+
+        it "opens a tunnel through the gateway" do
+          mock(subject).tunnel_to("some-director.com", 25555, "user@some-gateway") do
+            1234
+          end
+
+          director = subject.director("some-director.com", "user@some-gateway")
+          expect(director.director_uri.host).to eq("127.0.0.1")
+          expect(director.director_uri.port).to eq(1234)
+        end
+      end
+    end
+
+    describe "#login_to_director" do
+      let(:director) { stub }
+
+      before do
+        stub(director).user = anything
+        stub(director).password = anything
+        stub(director).authenticated? { true }
+      end
+
+      it "assigns the given user/pass on the director" do
+        mock(director).user = "user"
+        mock(director).password = "pass"
+        subject.login_to_director(director, "user", "pass")
+      end
+
+      it "returns true iff director.authenticated?" do
+        mock(director).authenticated? { true }
+        expect(subject.login_to_director(director, "user", "pass")).to be_true
+      end
+
+      it "returns false iff !director.authenticated?" do
+        mock(director).authenticated? { false }
+        expect(subject.login_to_director(director, "user", "pass")).to be_false
+      end
+    end
+
+    describe "#tunnel_to" do
+      let(:gateway) { stub }
+
+      before do
+        stub(gateway).open
+      end
+
+      it "creates a gateway using the given user/host" do
+        mock(Net::SSH::Gateway).new("ghost", "guser") { gateway }
+        subject.tunnel_to("1.2.3.4", 1234, "guser@ghost")
+      end
+
+      it "opens a local tunnel and returns its port" do
+        stub(Net::SSH::Gateway).new("ghost", "guser") { gateway }
+        mock(gateway).open("1.2.3.4", 1234) { 5678 }
+        expect(subject.tunnel_to("1.2.3.4", 1234, "guser@ghost")).to eq(5678)
+      end
+    end
+
+    describe "#authenticate_with_director" do
+      let(:director) { stub }
+
+      def self.it_asks_interactively
+        it "asks for the credentials interactively" do
+          if saved_credentials
+            mock(subject).login_to_director(director, "user", "pass") { false }.ordered
+          end
+
+          mock_ask("Director Username") { "fizz" }.ordered
+          mock_ask("Director Password", anything) { "buzz" }.ordered
+
+          mock(subject).login_to_director(director, "fizz", "buzz") { true }.ordered
+
+          subject.authenticate_with_director(director, "foo", saved_credentials)
+        end
+
+        context "when the interactive user/pass is valid" do
+          it "returns true" do
+            if saved_credentials
+              mock(subject).login_to_director(director, "user", "pass") { false }.ordered
+            end
+
+            mock_ask("Director Username") { "fizz" }.ordered
+            mock_ask("Director Password", anything) { "buzz" }.ordered
+
+            mock(subject).login_to_director(director, "fizz", "buzz") { true }.ordered
+
+            expect(
+              subject.authenticate_with_director(director, "foo", saved_credentials)
+            ).to be_true
+          end
+
+          it "saves them to the bosh config" do
+            if saved_credentials
+              mock(subject).login_to_director(director, "user", "pass") { false }.ordered
+            end
+
+            mock_ask("Director Username") { "fizz" }.ordered
+            mock_ask("Director Password", anything) { "buzz" }.ordered
+
+            mock(subject).login_to_director(director, "fizz", "buzz") { true }.ordered
+
+            mock(subject).save_auth("foo", "username" => "fizz", "password" => "buzz")
+
+            subject.authenticate_with_director(director, "foo", saved_credentials)
+          end
+        end
+
+        context "when the interactive user/pass is invalid" do
+          it "asks again" do
+            if saved_credentials
+              mock(subject).login_to_director(director, "user", "pass") { false }.ordered
+            end
+
+            mock_ask("Director Username") { "fizz" }.ordered
+            mock_ask("Director Password", anything) { "buzz" }.ordered
+
+            mock(subject).login_to_director(director, "fizz", "buzz") { false }.ordered
+
+            mock_ask("Director Username") { "a" }.ordered
+            mock_ask("Director Password", anything) { "b" }.ordered
+
+            mock(subject).login_to_director(director, "a", "b") { true }.ordered
+
+            subject.authenticate_with_director(director, "foo", saved_credentials)
+          end
+        end
+      end
+
+      context "when saved credentials are given" do
+        let(:saved_credentials) { { "username" => "user", "password" => "pass" } }
+
+        context "and they are valid" do
+          it "returns true" do
+            mock(subject).login_to_director(director, "user", "pass") { true }
+
+            expect(
+              subject.authenticate_with_director(
+                director, "foo", "username" => "user", "password" => "pass")
+            ).to be_true
+          end
+        end
+
+        context "and they are NOT valid" do
+          it_asks_interactively
+        end
+      end
+
+      context "when auth credentials are NOT given" do
+        let(:saved_credentials) { nil }
+
+        it_asks_interactively
+      end
+    end
+  end
+end

data/spec/tunnel/log_entry_spec.rb

@@ -0,0 +1,109 @@
+require "spec_helper"
+
+describe CFTools::Tunnel::LogEntry do
+  let(:label) { "some-label" }
+  let(:line) { "something happened!" }
+  let(:stream) { :stdout }
+
+  subject { described_class.new(label, line, stream) }
+
+  describe "#label" do
+    let(:label) { "some-label" }
+
+    it "returns the label of the entry" do
+      expect(subject.label).to eq("some-label")
+    end
+  end
+
+  describe "#line" do
+    let(:line) { "something happened!" }
+
+    it "returns the line of the entry" do
+      expect(subject.line).to eq("something happened!")
+    end
+  end
+
+  describe "#stream" do
+    let(:stream) { :stdout }
+
+    it "returns the stream of the entry" do
+      expect(subject.stream).to eq(:stdout)
+    end
+  end
+
+  describe "#message" do
+    context "when the line is JSON" do
+      let(:line) { '{"message":"foo"}' }
+
+      it "return its 'message' field" do
+        expect(subject.message).to eq("foo")
+      end
+    end
+
+    context "when the line is NOT JSON" do
+      let(:line) { "bar" }
+
+      it "returns the line" do
+        expect(subject.message).to eq("bar")
+      end
+    end
+  end
+
+  describe "#log_level" do
+    context "when the line is JSON" do
+      let(:line) { '{"log_level":"debug"}' }
+
+      it "return its 'log_level' field" do
+        expect(subject.log_level).to eq("debug")
+      end
+    end
+
+    context "when the line is NOT JSON" do
+      let(:line) { "bar" }
+
+      it "returns nil" do
+        expect(subject.log_level).to be_nil
+      end
+    end
+  end
+
+  describe "#timestamp" do
+    let(:time) { Time.now }
+
+    around { |example| Timecop.freeze(&example) }
+
+    context "when the line is JSON" do
+      context "and the timestamp is a string" do
+        let(:line) { %Q[{"timestamp":"#{time.strftime("%F %T")}"}] }
+
+        it "return its parsed 'timestamp' field" do
+          expect(subject.timestamp.to_s).to eq(time.to_s)
+        end
+      end
+
+      context "and the timestamp is numeric" do
+        let(:line) { %Q[{"timestamp":#{time.to_f}}] }
+
+        it "interprets it as time since UNIX epoch" do
+          expect(subject.timestamp.to_s).to eq(time.to_s)
+        end
+      end
+
+      context "and the timestamp is missing" do
+        let(:line) { %Q[{}] }
+
+        it "returns the time at which the entry was created" do
+          expect(subject.timestamp).to eq(time)
+        end
+      end
+    end
+
+    context "when the line is NOT JSON" do
+      let(:line) { "bar" }
+
+      it "returns the time at which the entry was created" do
+        expect(subject.timestamp).to eq(time)
+      end
+    end
+  end
+end

data/spec/tunnel/multi_line_stream_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+module CFTools::Tunnel
+  describe MultiLineStream do
+    let(:director) { stub }
+    let(:deployment) { "some-deployment" }
+    let(:gateway_user) { "vcap" }
+    let(:gateway_host) { "vcap.me" }
+
+    let(:gateway) { stub }
+    let(:entries) { Queue.new }
+
+    subject do
+      described_class.new(director, deployment, gateway_user, gateway_host)
+    end
+
+    before do
+      stub(subject).create_ssh_user { ["1.2.3.4", "some_user_1"] }
+      stub(subject).gateway { gateway }
+      stub(subject).entry_queue { entries }
+      stub(Thread).new { |blk| blk.call }
+    end
+
+    describe "#stream" do
+      it "yields entries as they come through the queue" do
+        entries << :a
+        entries << :b
+        entries << nil
+
+        seen = []
+        subject.stream({}) do |e|
+          seen << e
+        end
+        
+        expect(seen).to eq([:a, :b])
+      end
+
+      it "spawns a SSH tunnel for each location" do
+        mock(Thread).new { |blk| blk.call }.ordered
+        mock(Thread).new { |blk| blk.call }.ordered
+
+        mock(subject).create_ssh_user("foo", 0, entries) { ["1.2.3.4", "some_user_1"] }
+        mock(subject).create_ssh_user("bar", 0, entries) { ["1.2.3.5", "some_user_2"] }
+
+        mock(gateway).ssh("1.2.3.4", "some_user_1")
+        mock(gateway).ssh("1.2.3.5", "some_user_2")
+
+        entries << nil
+
+        subject.stream(["foo", 0] => [], ["bar", 0]=> [])
+      end
+
+      it "streams from each location" do
+        ssh = stub
+
+        locations = {
+          "1.2.3.4" => [
+            StreamLocation.new("some/path", "some-label"),
+            StreamLocation.new("some/other/path", "some-label")
+          ],
+          "1.2.3.5" => [
+            StreamLocation.new("some/path", "other-label"),
+          ]
+        }
+
+        locations.each do |_, locs|
+          locs.each do |loc|
+            mock(loc).stream_lines(ssh)
+          end
+        end
+
+        stub(gateway).ssh { |_, _, blk| blk.call(ssh) }
+
+        entries << nil
+
+        subject.stream(locations)
+      end
+    end
+  end
+end

data/spec/tunnel/stream_location_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe CFTools::Tunnel::StreamLocation do
+  let(:path) { "some/file" }
+  let(:label) { "some_component/0" }
+
+  subject { described_class.new(path, label) }
+
+  describe "#path" do
+    let(:path) { "some/path" }
+
+    it "returns the path of the entry" do
+      expect(subject.path).to eq("some/path")
+    end
+  end
+
+  describe "#label" do
+    let(:label) { "some-label" }
+
+    it "returns the label of the entry" do
+      expect(subject.label).to eq("some-label")
+    end
+  end
+
+  describe "#stream_lines" do
+    let(:ssh) { stub }
+
+    it "tails the file under /var/vcap/sys/log" do
+      mock(ssh).exec("tail -f /var/vcap/sys/log/#{path}")
+      subject.stream_lines(ssh)
+    end
+
+    it "yields log entries as lines come through the channel" do
+      stub(ssh).exec { |_, blk| blk.call({}, :stdout, "foo\nbar\n") }
+
+      lines = []
+      subject.stream_lines(ssh) do |entry|
+        lines << entry.message
+      end
+
+      expect(lines).to eq(["foo\n", "bar\n"])
+    end
+
+    it "merges chunks that form a complete line" do
+      channel = {}
+      stub(ssh).exec do |_, blk|
+        blk.call(channel, :stdout, "fo")
+        blk.call(channel, :stdout, "o\nbar\n")
+      end
+
+      lines = []
+      subject.stream_lines(ssh) do |entry|
+        lines << entry.message
+      end
+
+      expect(lines).to eq(["foo\n", "bar\n"])
+    end
+  end
+end

data/spec/tunnel/watch_logs_spec.rb

@@ -0,0 +1,117 @@
+require "spec_helper"
+
+module CFTools::Tunnel
+  describe WatchLogs do
+    let(:director_uri) { "https://some-director.com:25555" }
+
+    let(:director) { Bosh::Cli::Director.new(director_uri) }
+
+    let(:stream) { stub }
+
+    let(:vms) do
+      [ { "ips" => ["1.2.3.4"], "job_name" => "cloud_controller", "index" => 0 },
+        { "ips" => ["1.2.3.5"], "job_name" => "dea_next", "index" => 0 },
+        { "ips" => ["1.2.3.6"], "job_name" => "dea_next", "index" => 1 }
+      ]
+    end
+
+    let(:deployments) do
+      [{ "name" => "some-deployment",  "releases" => [{ "name" => "cf-release" }] }]
+    end
+
+    def mock_cli
+      any_instance_of(described_class) do |cli|
+        mock(cli)
+      end
+    end
+
+    def stub_cli
+      any_instance_of(described_class) do |cli|
+        stub(cli)
+      end
+    end
+
+    before do
+      stub(director).list_deployments { deployments }
+      stub(director).fetch_vm_state { vms }
+      stub_cli.connected_director { director }
+
+      stub(stream).stream
+      stub_cli.stream_for { stream }
+    end
+
+    it "connects to the given director" do
+      mock_cli.connected_director(
+          "some-director.com", "someuser@somehost.com") do
+        director
+      end
+
+      cf %W[watch-logs some-director.com --gateway someuser@somehost.com]
+    end
+
+    context "when no gateway user/host is specified" do
+      it "defaults to vcap@director" do
+        mock_cli.connected_director(
+            "some-director.com", "vcap@some-director.com") do
+          director
+        end
+
+        cf %W[watch-logs some-director.com]
+      end
+    end
+
+    context "when there are no jobs to log" do
+      let(:vms) { [] }
+
+      it "fails with a message" do
+        cf %W[watch-logs some-director.com]
+        expect(error_output).to say("No locations found.")
+      end
+    end
+
+    context "when there are jobs to log" do
+      it "streams their locations" do
+        mock(stream).stream(anything) do |locations, blk|
+          expect(locations).to include(["cloud_controller", 0])
+          expect(locations).to include(["dea_next", 0])
+          expect(locations).to include(["dea_next", 1])
+        end
+
+        cf %W[watch-logs some-director.com]
+      end
+
+      it "pretty-prints their log entries" do
+        entry1_time = Time.new(2011, 06, 21, 1, 2, 3)
+        entry2_time = Time.new(2011, 06, 21, 1, 2, 4)
+        entry3_time = Time.new(2011, 06, 21, 1, 2, 5)
+
+        entry1 = LogEntry.new(
+          "cloud_controller/0",
+          %Q[{"message":"a","timestamp":#{entry1_time.to_f},"log_level":"info"}],
+          :stdout)
+
+        entry2 = LogEntry.new(
+          "dea_next/1",
+          %Q[{"message":"b","timestamp":#{entry2_time.to_f},"log_level":"warn"}],
+          :stdout)
+
+        entry3 = LogEntry.new(
+          "dea_next/0",
+          %Q[{"message":"c","timestamp":#{entry3_time.to_f},"log_level":"error"}],
+          :stdout)
+
+        mock(stream).stream(anything) do |locations, blk|
+          blk.call(entry1)
+          blk.call(entry2)
+          blk.call(entry3)
+        end
+
+        cf %W[watch-logs some-director.com]
+
+        expect(output).to say("cloud_controller/0   01:02:03 AM  info    a\n")
+        expect(output).to say("dea_next/1           01:02:04 AM  warn    b\n")
+        expect(output).to say("dea_next/0           01:02:05 AM  error   c\n")
+      end
+    end
+  end
+end