status_page_ruby 0.0.1

data/lib/status_page_ruby/services/build_log_table.rb

@@ -0,0 +1,14 @@
+module StatusPageRuby
+  module Services
+    class BuildLogTable
+      HEADINGS = %w[Service Status Time].freeze
+
+      def call(records)
+        Terminal::Table.new(
+          headings: HEADINGS,
+          rows: records.map(&:history_record)
+        ).to_s
+      end
+    end
+  end
+end

data/lib/status_page_ruby/services/build_stats_table.rb

@@ -0,0 +1,79 @@
+module StatusPageRuby
+  module Services
+    class BuildStatsTable
+      HEADINGS = ['Service', 'Up since', 'Down time'].freeze
+      SECONDS_IN_MINUTE = 60
+      SECONDS_IN_HOUR = 3600
+      SECONDS_IN_DAY = 86_400
+
+      attr_reader :status_repository
+
+      def initialize(status_repository)
+        @status_repository = status_repository
+      end
+
+      def call(service = nil)
+        Terminal::Table.new(
+          headings: HEADINGS,
+          rows: build_rows(service)
+        ).to_s
+      end
+
+      private
+
+      def build_rows(service)
+        find_records(service)
+          .group_by(&:service)
+          .each_with_object([]) do |(key, records), results|
+
+          results << [
+            key,
+            readable_time_amount(calculate_up_since(records)),
+            readable_time_amount(calculate_down_time(records))
+          ]
+        end
+      end
+
+      def calculate_down_time(records)
+        records
+          .sort_by { |record| record.time.to_i }
+          .each_cons(2)
+          .inject(0) { |result, (first, second)| result + duration_between(first, second) }
+      end
+
+      def duration_between(first, second)
+        return 0 if first.up?
+
+        (second.nil? ? Time.now.to_i : second.time.to_i) - first.time.to_i
+      end
+
+      def calculate_up_since(records)
+        record = take_up_since(records)
+        return if record.nil?
+
+        Time.now.to_i - record.time.to_i
+      end
+
+      def readable_time_amount(duration_sec)
+        return 'N/A' if duration_sec.nil?
+        return "#{duration_sec / SECONDS_IN_MINUTE} minutes" if duration_sec < SECONDS_IN_HOUR
+        return "#{duration_sec / SECONDS_IN_HOUR} hours" if duration_sec < SECONDS_IN_DAY
+
+        "#{duration_sec / SECONDS_IN_DAY} days"
+      end
+
+      def take_up_since(records)
+        records
+          .sort_by { |record| -record.time.to_i }
+          .take_while(&:up?)
+          .first
+      end
+
+      def find_records(service)
+        return status_repository.all if service.nil?
+
+        status_repository.where(service: service)
+      end
+    end
+  end
+end

data/lib/status_page_ruby/services/pull_statuses.rb

@@ -0,0 +1,44 @@
+module StatusPageRuby
+  module Services
+    class PullStatuses
+      attr_reader :status_repository
+
+      def initialize(status_repository)
+        @status_repository = status_repository
+      end
+
+      def call
+        fetch_statuses.tap do |statuses|
+          status_repository.create_batch(statuses) unless statuses.empty?
+        end
+      end
+
+      private
+
+      def fetch_statuses
+        page_classes
+          .map(&:open)
+          .map(&method(:build_status))
+      end
+
+      def page_classes
+        ObjectSpace
+          .each_object(Class)
+          .select(&method(:page_class?))
+      end
+
+      def page_class?(klass)
+        klass < ::StatusPageRuby::Pages::Base
+      end
+
+      def build_status(page)
+        StatusPageRuby::Status.new(
+          page.class.name.split('::').last,
+          page.success? ? 'up' : 'down',
+          page.status,
+          page.time
+        )
+      end
+    end
+  end
+end

data/lib/status_page_ruby/services/restore_data.rb

@@ -0,0 +1,15 @@
+module StatusPageRuby
+  module Services
+    class RestoreData
+      attr_reader :storage
+
+      def initialize(storage)
+        @storage = storage
+      end
+
+      def call(path)
+        storage.restore(path)
+      end
+    end
+  end
+end

data/lib/status_page_ruby/status.rb

@@ -0,0 +1,36 @@
+module StatusPageRuby
+  class Status
+    HISTORY_RECORD_TIME_FORMAT = '%d.%m.%Y %H:%M:%S'.freeze
+    UP_STATE = 'up'.freeze
+    DOWN_STATE = 'down'.freeze
+
+    attr_reader :service, :state, :status, :time
+
+    def initialize(service, state, status, time)
+      @service = service.to_s
+      @state = state.to_s
+      @status = status.to_s
+      @time = time.to_s
+    end
+
+    def up?
+      state == UP_STATE
+    end
+
+    def down?
+      state == DOWN_STATE
+    end
+
+    def history_record
+      [service, state, Time.at(time.to_i).utc.strftime(HISTORY_RECORD_TIME_FORMAT)]
+    end
+
+    def record
+      [service, state, status, time]
+    end
+
+    def to_csv
+      record.to_csv
+    end
+  end
+end

data/lib/status_page_ruby/storage.rb

@@ -0,0 +1,55 @@
+module StatusPageRuby
+  class Storage
+    attr_reader :data_file_path
+
+    def initialize(data_file_path)
+      validate_file(data_file_path)
+      @data_file_path = data_file_path
+    end
+
+    def include?(record)
+      read.lazy.include?(record)
+    end
+
+    def read
+      CSV.foreach(data_file_path)
+    end
+
+    def write(record)
+      CSV.open(data_file_path, 'a') do |csv|
+        csv << record
+      end
+    end
+
+    def merge(records)
+      updated_records = merge_records(records)
+      CSV.open(data_file_path, 'w') do |csv|
+        updated_records.each do |record|
+          csv << record
+        end
+      end
+    end
+
+    def copy(target_file_path)
+      FileUtils.mkpath(File.dirname(target_file_path))
+      FileUtils.cp(data_file_path, target_file_path)
+    end
+
+    def restore(new_file_path)
+      validate_file(new_file_path)
+      merge(CSV.foreach(new_file_path).to_a)
+    end
+
+    private
+
+    def validate_file(path)
+      return if File.file?(path.to_s) && File.readable?(path.to_s)
+
+      raise ArgumentError, 'Invalid file given.'
+    end
+
+    def merge_records(records)
+      (read.to_a | records).sort_by(&:last)
+    end
+  end
+end

data/lib/status_page_ruby/version.rb

@@ -0,0 +1,3 @@
+module StatusPageRuby
+  VERSION = '0.0.1'.freeze
+end

data/lib/status_page_ruby_cli.rb

@@ -0,0 +1,76 @@
+class StatusPageRubyCli < Thor
+  PULL_SECONDS = 10
+
+  def initialize(*args)
+    super(*args)
+    data_file_path = File.join(ENV['HOME'], '.status_page_ruby_data.csv')
+    create_data_file_if_needed(data_file_path)
+    storage = StatusPageRuby::Storage.new(data_file_path)
+    repository = StatusPageRuby::Repositories::Status.new(storage)
+    setup_services(repository)
+  end
+
+  desc :pull, 'Pulls, saves and optionally log statuses.'
+  option :log, type: :boolean
+  def pull
+    records = pull_statuses.call
+    puts build_log_table.call(records) if options[:log]
+  end
+
+  desc :live, "Pulls, saves and log statuses every #{PULL_SECONDS} seconds."
+  def live
+    loop do
+      puts build_log_table.call(pull_statuses.call)
+      sleep PULL_SECONDS
+    end
+  end
+
+  desc :history, 'Display all the data which was gathered.'
+  option :service, type: :string, required: false
+  def history
+    puts build_history_table.call(options[:service])
+  end
+
+  desc :stats, 'Summarizes the data and displays it.'
+  option :service, type: :string, required: false
+  def stats
+    puts build_stats_table.call(options[:service])
+  end
+
+  desc :backup, 'Backups data.'
+  option :path, type: :string, required: true
+  def backup
+    backup_data.call(options[:path])
+  end
+
+  desc :restore, 'Restores data.'
+  option :path, type: :string, required: true
+  def restore
+    restore_data.call(options[:path])
+  end
+
+  private
+
+  attr_reader :build_history_table,
+              :build_log_table,
+              :build_stats_table,
+              :pull_statuses,
+              :backup_data,
+              :restore_data
+
+  def setup_services(status_repository)
+    @build_history_table = StatusPageRuby::Services::BuildHistoryTable.new(status_repository)
+    @build_log_table = StatusPageRuby::Services::BuildLogTable.new
+    @build_stats_table = StatusPageRuby::Services::BuildStatsTable.new(status_repository)
+    @pull_statuses = StatusPageRuby::Services::PullStatuses.new(status_repository)
+    @backup_data = StatusPageRuby::Services::BackupData.new(status_repository.storage)
+    @restore_data = StatusPageRuby::Services::RestoreData.new(status_repository.storage)
+  end
+
+  def create_data_file_if_needed(path)
+    return if File.exist?(path)
+
+    FileUtils.mkpath(File.dirname(path))
+    FileUtils.touch(path)
+  end
+end

data/spec/lib/status_page_ruby/pages/bitbucket_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+RSpec.describe StatusPageRuby::Pages::Bitbucket do
+  let(:html) { "<html><body><div class='page-status'><div class='status'>#{status}</div></div></body></html>" }
+
+  before { allow(OpenURI).to receive(:open_uri).with('https://status.bitbucket.org/') { html } }
+
+  describe '#status' do
+    subject { described_class.open.status }
+
+    context 'when success status' do
+      let(:status) { 'All Systems Operational' }
+
+      it { is_expected.to eq('All Systems Operational') }
+    end
+
+    context 'when not success status' do
+      let(:status) { 'All is Failed' }
+
+      it { is_expected.to eq('All is Failed') }
+    end
+  end
+
+  describe '#success?' do
+    subject { described_class.open.success? }
+
+    context 'when success status' do
+      let(:status) { 'All Systems Operational' }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when not success status' do
+      let(:status) { 'All is Failed' }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+end

data/spec/lib/status_page_ruby/pages/cloudflare_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+RSpec.describe StatusPageRuby::Pages::Cloudflare do
+  let(:html) do
+    <<-HTML
+      <html>
+      <body>
+      <div class='page-status'>
+        <div class='status'>All is Failed</div>
+      </div>
+      <div data-component-id>
+        <div class="component-status">#{component_status}</div>
+      </div>
+      </body>
+      </html>
+    HTML
+  end
+
+  before { allow(OpenURI).to receive(:open_uri).with('https://www.cloudflarestatus.com/') { html } }
+
+  describe '#status' do
+    subject { described_class.open.status }
+
+    context 'when component_status is Failed' do
+      let(:component_status) { 'Failed' }
+
+      it { is_expected.to eq('All is Failed') }
+    end
+
+    context 'when component_status is Re-routed' do
+      let(:component_status) { 'Re-routed' }
+
+      it { is_expected.to eq('All Systems Operational') }
+    end
+
+    context 'when component_status is Operational' do
+      let(:component_status) { 'Operational' }
+
+      it { is_expected.to eq('All Systems Operational') }
+    end
+  end
+
+  describe '#success?' do
+    subject { described_class.open.success? }
+
+    context 'when component_status is Failed' do
+      let(:component_status) { 'Failed' }
+
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when component_status is Re-routed' do
+      let(:component_status) { 'Re-routed' }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when component_status is Operational' do
+      let(:component_status) { 'Operational' }
+
+      it { is_expected.to be_truthy }
+    end
+  end
+end

data/spec/lib/status_page_ruby/pages/github_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+RSpec.describe StatusPageRuby::Pages::Github do
+  let(:html) do
+    <<-HTML
+      <html>
+      <body>
+      <div class='message'>
+        <div class='title'>#{status}</div>
+        <div class='time' datetime='2018-10-12T22:00:00.000Z'></div>
+      </div>
+      </body>
+      </html>
+    HTML
+  end
+
+  before { allow(OpenURI).to receive(:open_uri).with('https://status.github.com/messages') { html } }
+
+  describe '#status' do
+    subject { described_class.open.status }
+
+    context 'when success status' do
+      let(:status) { 'All systems reporting at 100%' }
+
+      it { is_expected.to eq('All systems reporting at 100%') }
+    end
+
+    context 'when not success status' do
+      let(:status) { 'All is Failed' }
+
+      it { is_expected.to eq('All is Failed') }
+    end
+  end
+
+  describe '#time' do
+    subject { described_class.open.time }
+    let(:status) { 'All systems reporting at 100%' }
+
+    it { is_expected.to eq(1_539_381_600) }
+  end
+
+  describe '#success?' do
+    subject { described_class.open.success? }
+
+    context 'when success status' do
+      let(:status) { 'All systems reporting at 100%' }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when not success status' do
+      let(:status) { 'All is Failed' }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+end