cloudcost 0.2.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b79b93bfa4a348fdc4d6990402400ebf709ff1cb9c8a105816f39beefc5209f4
-  data.tar.gz: 281358b34a8c77704a074fa9399b6b9d0f1ffda9d7ca96a4d3b30f6ad40794a0
+  metadata.gz: e9d9dcfa0be1af8bdca48829a644e2537b44f74ccc67a39a96c1b6995287fe9a
+  data.tar.gz: c886680ef321bb68f8241f8e1b146dc6e76070cc15e950e7a8724a55dec9cdf5
 SHA512:
-  metadata.gz: 0541d3c1e6904a79903b45980b4fd5de642f01da8df6bfd3e038f5f0f18e9bbb33d46cbf58f2898f249f9757297609be7e03ec5e5674b8a047bd1bb2840e4761
-  data.tar.gz: 93562d90574c73387a5cd6d57637e36836cc480fd045c03ac3459331028cf6b0c16886c9642f403a6adacffdc77cf3021eb20995fa102ae664510dfc70b12f6e
+  metadata.gz: 2b68e3c49dac3c5eae508aa31a0eb1fdd124e314a1c90fb3d0b5e03c56e57266c37f7c9dd2b20e1f74700e6d4853c0b7986fdf798a38b3d89e714b463b88530a
+  data.tar.gz: 33c6d53ddb662a3cdcb7ebace5a569853ab49439dc2f2cf5a49122eb40cae1433ffdce765f97d73613415dfcde9b32fced9f0b57056a7196e22b1dc289304248

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    cloudcost (0.0.1)
-      excon (~> 0.82.0)
+    cloudcost (0.4.1)
+      excon (~> 0.85.0)
       parseconfig (~> 1.1.0)
       terminal-table (~> 3.0.1)
       thor (~> 1.1.0)
@@ -11,15 +11,15 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    excon (0.82.0)
+    excon (0.85.0)
     parseconfig (1.1.0)
-    terminal-table (3.0.1)
+    terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
     thor (1.1.0)
     tty-cursor (0.7.1)
     tty-spinner (0.9.3)
       tty-cursor (~> 0.7)
-    unicode-display_width (2.0.0)
+    unicode-display_width (2.1.0)
 
 PLATFORMS
   ruby

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Puzzle ITC
+Copyright (c) 2021 Nik Wolfgramm
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -19,8 +19,7 @@ gem install cloudcost
 
 cloudcost does support the same auth configuration options as [cloudscale-cli](https://cloudscale-ch.github.io/cloudscale-cli/).
 
-You can manage multiple profiles using `cloudscale.ini` files ([see here](https://cloudscale-ch.github.io/cloudscale-cli/auth/) for instructions). 
-
+You can manage multiple profiles using `cloudscale.ini` files ([see here](https://cloudscale-ch.github.io/cloudscale-cli/auth/) for instructions).
 
 Otherwise you can export a `CLOUDSCALE_API_TOKEN` in your environment:
 
@@ -66,7 +65,7 @@ cloudcost servers --summary
 
 #### Group and summarize by tag
 
-By using the `--tag-by` option, you can summarize usage by tag:
+By using the `--group-by` option, you can summarize usage by tag:
 
 ```sh
 cloudcost servers --group-by budget-group
@@ -87,6 +86,19 @@ cloudcost servers --group-by budget-group --profile prod | \
 influx write --bucket my-bucket --org my-org --token my-super-secret-auth-token
 ```
 
+Example Flux-Query for loading data from InfluxDB:
+
+```sh
+influx query --org my-org --token my-super-secret-auth-token \
+'from(bucket:"my-bucket")
+  |> range(start: -1d)
+  |> filter(fn: (r) =>
+    r._measurement == "cloudscaleServerCosts" and
+    r._field == "cost_per_day") and
+    r.profile == "prod" and 
+    r.group == "my-budget-group"'
+```
+
 #### CSV Output
 
 Output in CSV format instead of a table:
@@ -154,3 +166,37 @@ cloudcost server-tags --name ldap --set-tags owner=sys budget-group=base-infrast
 ```sh
 cloudcost server-tags --name ldap --remove-tags owner budget-group
 ```
+
+### Volumes
+
+List all volumes:
+
+```sh
+cloudcost volumes
+```
+
+Only list volumes of type `bulk`
+
+```sh
+cloudcost volumes --type bulk
+```
+
+List volumes which are not attached to a server:
+
+```sh
+cloudcost volumes --no-attached
+```
+
+Filter volumes by names:
+
+```sh
+cloudcost volumes --name "pvc"
+```
+
+Output as InfluxDB Line Protocol:
+
+```sh
+cloudcost volumes --output influx --profile prod --no-attached
+```
+
+NOTE: The Line Protocol output includes a tag `state` which is either "attached", "unattached" or "all".

data/Rakefile

@@ -6,3 +6,17 @@ require "rubocop/rake_task"
 RuboCop::RakeTask.new
 
 task default: %i[rubocop]
+
+DOCKER_REGISTRY = "registry.puzzle.ch/puzzle/cloudcost"
+
+desc "Build the docker image and tag it with the current version."
+task :docker_build do
+  puts command = "docker build -t #{DOCKER_REGISTRY}:#{Cloudcost::VERSION} ."
+  puts `#{command}`
+end
+
+desc "Push the newest docker image."
+task :docker_push do
+  puts command = "docker push #{DOCKER_REGISTRY}:#{Cloudcost::VERSION}"
+  puts `#{command}`
+end

data/cloudcost.gemspec

@@ -10,8 +10,7 @@ Gem::Specification.new do |s|
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nik Wolfgramm"]
-  s.description = "Calculate cloudscale.ch server costs from your actual deployment"
-  s.email = "wolfgramm@puzzle.ch"
+  s.description = "Calculate cloudscale.ch server costs from the current deployment"
   s.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   s.require_paths = ["lib"]
   s.required_ruby_version = ">= 2.7"
@@ -20,7 +19,7 @@ Gem::Specification.new do |s|
   s.test_files = s.files.grep(%r{^(test|spec|features)/})
   s.license = "MIT"
 
-  s.add_dependency("excon", "~> 0.82.0")
+  s.add_dependency("excon", "~> 0.85.0")
   s.add_dependency("parseconfig", "~> 1.1.0")
   s.add_dependency("terminal-table", "~> 3.0.1")
   s.add_dependency("thor", "~> 1.1.0")

data/lib/cloudcost/api_connection.rb

@@ -4,6 +4,7 @@ require "excon"
 require "json"
 
 module Cloudcost
+  # Connecting to and accessing the cloudscale.ch API
   class ApiConnection
     API_URL = "https://api.cloudscale.ch"
 
@@ -38,6 +39,19 @@ module Cloudcost
       )
     end
 
+    def get_volumes(options = {})
+      volumes = get_resource("volumes", options)
+      volumes = volumes.reject { |volume| volume[:tags].key?(options[:missing_tag].to_sym) } if options[:missing_tag]
+      volumes = volumes.select { |volume| /#{options[:name]}/.match? volume[:name] } if options[:name]
+      volumes = volumes.select { |volume| /#{options[:type]}/.match? volume[:type] } if options[:type]
+      unless options[:attached].nil?
+        volumes = volumes.select do |volume|
+          (volume[:servers].size.positive?) == options[:attached]
+        end
+      end
+      volumes
+    end
+
     private
 
     def new_connection

data/lib/cloudcost/api_token.rb

@@ -3,9 +3,9 @@
 require "parseconfig"
 require "excon"
 require "json"
-require "cloudcost/error"
 
 module Cloudcost
+  # Support for cloudscale-cli style API-tokens and profiles
   class ApiToken
     attr_accessor :profile, :token
 

data/lib/cloudcost/cli.rb

@@ -4,6 +4,7 @@ require "thor"
 require "tty-spinner"
 
 module Cloudcost
+  # Implementaion of CLI functionality
   class CLI < Thor
     # Error raised by this runner
     Error = Class.new(StandardError)
@@ -38,22 +39,18 @@ module Cloudcost
         spinner = TTY::Spinner.new("[:spinner] Calculating costs...", clear: options[:csv])
         spinner.auto_spin
       end
-      output(servers, options) do |result|
-        spinner.success("(done)") if spinner
+      output_servers(servers, options) do |result|
+        spinner&.success("(done)")
         puts result
       end
     rescue Excon::Error, TokenError, ProfileError, PricingError => e
       error_message = "ERROR: #{e.message}"
-      if spinner
-        spinner.error("(#{error_message})")
-      else
-        puts error_message
-      end
+      spinner ? spinner.error(error_message) : puts(error_message)
     end
 
     desc "server-tags", "show and assign tags of servers"
     option :name, desc: "filter name by regex", aliases: %w[-n]
-    option :tag, desc: "filter servers by tag", aliases: %w[-t]
+    option :tag, desc: "filter by tag", aliases: %w[-t]
     option :set_tags,
            desc: "set tags",
            aliases: %w[-T],
@@ -79,19 +76,40 @@ module Cloudcost
             (options[:remove_tags] || []).each do |tag|
               tags.reject! { |k| k == tag.to_sym }
             end
-            api_connection(options).set_server_tags(server.uuid, tags)
-            spinner.success
+            begin
+              api_connection(options).set_server_tags(server.uuid, tags)
+              spinner.success
+            rescue Excon::Error => e
+              spinner.error "ERROR: #{e.message}"
+            end
           end
         end
         spinners.auto_spin
       end
-    rescue Excon::Error, TokenError, ProfileError => e
-      error_message = "ERROR: #{e.message}"
-      if defined?(spinner)
-        spinner.error("(#{error_message})")
-      else
-        puts error_message
+    rescue Cloudcost::TokenError, Cloudcost::ProfileError => e
+      puts "ERROR: #{e.message}"
+    end
+
+    desc "volumes", "explore volumes"
+    option :name, desc: "filter name by regex", aliases: %w[-n]
+    option :tag, desc: "filter by tag", aliases: %w[-t]
+    option :summary, desc: "display totals only", type: :boolean, aliases: %w[-S]
+    option :type, enum: %w[ssd bulk], desc: "volume type"
+    option :attached, type: :boolean, desc: "volume attached to servers"
+    option :output, default: "table", enum: %w[table csv influx], desc: "output format", aliases: %w[-o]
+    def volumes
+      volumes = load_volumes(options)
+      if options[:output] == "table"
+        spinner = TTY::Spinner.new("[:spinner] Calculating costs...", clear: options[:csv])
+        spinner.auto_spin
+      end
+      output_volumes(volumes, options) do |result|
+        spinner&.success("(done)")
+        puts result
       end
+    rescue Excon::Error, Cloudcost::TokenError, Cloudcost::ProfileError, Cloudcost::PricingError => e
+      error_message = "ERROR: #{e.message}"
+      spinner ? spinner.error(error_message) : puts(error_message)
     end
 
     no_tasks do
@@ -114,21 +132,55 @@ module Cloudcost
           spinner = TTY::Spinner.new("[:spinner] Loading servers...", clear: options[:csv])
           spinner.auto_spin
         end
-        servers = api_connection(options).get_servers(options).map { |server| Server.new(server) }
-        spinner.success "(#{servers.size} found)" if spinner
+        servers = api_connection(options).get_servers(options).map { |server| Cloudcost::Server.new(server) }
+        spinner&.success "(#{servers.size} found)"
         servers
+      rescue Excon::Error => e
+        spinner&.error "ERROR: #{e.message}"
+        []
+      end
+
+      def load_volumes(options)
+        if options[:output] == "table"
+          spinner = TTY::Spinner.new("[:spinner] Loading volumes...", clear: options[:csv])
+          spinner.auto_spin
+        end
+        volumes = api_connection(options).get_volumes(options).map { |volume| Cloudcost::Volume.new(volume) }
+        spinner&.success "(#{volumes.size} found)"
+        volumes
+      rescue Excon::Error => e
+        spinner&.error "\ERROR: #{e.message}"
+        []
       end
 
-      def output(servers, options)
-        if options[:group_by]
-          yield Cloudcost::ServerList.new(servers, options).grouped_cost_table
+      def output_servers(servers, options)
+        if servers.empty?
+          yield "WARNING: No servers found."
+        elsif options[:group_by]
+          yield Cloudcost::ServerList.new(servers, options).grouped_costs
         elsif options[:output] == "csv"
           yield Cloudcost::ServerList.new(servers, options).to_csv
         else
+          if options[:output] == "influx"
+            puts "ERROR: group-by option required for influx output"
+            exit 1
+          end
           yield Cloudcost::ServerList.new(servers, options).cost_table
         end
       end
 
+      def output_volumes(volumes, options)
+        if volumes.empty?
+          yield "WARNING: No volumes found."
+        elsif options[:output] == "csv"
+          yield Cloudcost::VolumeList.new(volumes, options).to_csv
+        elsif options[:output] == "influx"
+          yield Cloudcost::VolumeList.new(volumes, options).totals_influx_line_protocol
+        else
+          yield Cloudcost::VolumeList.new(volumes, options).cost_table
+        end
+      end
+
       def tag_option_to_s(options)
         messages = []
         messages << "set tags \"#{options[:set_tags].join(", ")}\"" if options[:set_tags]

data/lib/cloudcost/commands/csv_output.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Cloudcost
+  # generic CSV output methods
+  module CsvOutput
+    def groups_to_csv(group_rows)
+      CSV.generate do |csv|
+        csv << headings
+        group_rows.each { |row| csv << row }
+      end
+    end
+
+    def to_csv
+      CSV.generate do |csv|
+        csv << headings
+        if @options[:summary]
+          csv << totals
+        else
+          rows.each { |row| csv << row }
+        end
+      end
+    end
+  end
+end

data/lib/cloudcost/{server.rb → commands/server/server.rb}

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-require "cloudcost/pricing"
-
 module Cloudcost
   def self.tags_to_s(tag_hash = [])
     tag_hash.map { |k, v| "#{k}=#{v}" }.join(" ")
   end
 
+  # Representation of cloudscale.ch server object
   class Server
     attr_accessor :data
 

data/lib/cloudcost/commands/server/server_influxdb_output.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Cloudcost
+  # InfluxDB output methods for the ServerList class
+  module ServerInfluxdbOutput
+    def grouped_influx_line_protocol(group_rows)
+      lines = []
+      group_rows.each do |row|
+        [
+          { field: "server_count", position: 1, unit: "i" },
+          { field: "vcpus", position: 2, unit: "i" },
+          { field: "memory_gb", position: 3, unit: "i" },
+          { field: "ssd_gb", position: 4, unit: "i" },
+          { field: "bulk_gb", position: 5, unit: "i" },
+          { field: "chf_per_day", position: 6, unit: "" }
+        ].each do |field|
+          lines << %(
+            cloudscaleServerCosts,group=#{row[0]},profile=#{@options[:profile] || "?"}
+            #{field[:field]}=#{row[field[:position]]}#{field[:unit]}
+          ).gsub(/\s+/, " ").strip
+        end
+      end
+      lines.join("\n")
+    end
+  end
+end

data/lib/cloudcost/commands/server/server_list.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Cloudcost
+  # ServerList represents a list of servers and integrates several output methods
+  class ServerList
+    include Cloudcost::ServerTabularOutput
+    include Cloudcost::ServerInfluxdbOutput
+    include Cloudcost::CsvOutput
+
+    def initialize(servers, options = {})
+      @servers = servers
+      @options = options
+    end
+
+    def calculate_totals(servers = @servers)
+      totals = { vcpu: 0, memory: 0, ssd: 0, bulk: 0, cost: 0.0 }
+      servers.each do |server|
+        totals[:vcpu] += server.vcpu_count
+        totals[:memory] += server.memory_gb
+        totals[:ssd] += server.storage_size(:ssd)
+        totals[:bulk] += server.storage_size(:bulk)
+        totals[:cost] += server.total_costs_per_day
+      end
+      totals
+    end
+
+    def totals(servers = @servers)
+      totals = calculate_totals(servers)
+      total_row = @options[:summary] ? %w[Total] : ["Total", "", "", ""]
+      total_row.concat [
+        totals[:vcpu],
+        totals[:memory],
+        totals[:ssd],
+        totals[:bulk],
+        format("%.2f", totals[:cost].round(2)),
+        format("%.2f", (totals[:cost] * 30).round(2))
+      ]
+    end
+
+    def grouped_costs
+      no_tag = "<no-tag>"
+      group_rows = @servers.group_by { |s| s.tags[@options[:group_by].to_sym] || no_tag }.map do |name, servers|
+        server_groups_data(name, servers).values.flatten
+      end
+      group_rows.sort! { |a, b| a[0] == no_tag ? 1 : a[0] <=> b[0] }
+      case @options[:output]
+      when "csv"
+        groups_to_csv(group_rows)
+      when "influx"
+        grouped_influx_line_protocol(group_rows)
+      else
+        grouped_cost_table(group_rows)
+      end
+    end
+
+    def server_groups_data(name, servers)
+      data = { name: name, count: 0, vcpu: 0, memory: 0, ssd: 0, bulk: 0, costs_daily: 0 }
+      servers.each do |server|
+        data[:count] += 1
+        data[:vcpu] += server.vcpu_count
+        data[:memory] += server.memory_gb
+        data[:ssd] += server.storage_size(:ssd)
+        data[:bulk] += server.storage_size(:bulk)
+        data[:costs_daily] += server.total_costs_per_day
+      end
+      data[:costs_monthly] = (data[:costs_daily] * 30).round(2)
+      data[:costs_daily] = data[:costs_daily].round(2)
+      data
+    end
+  end
+end

data/lib/cloudcost/commands/server/server_tabular_output.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "terminal-table"
+
+module Cloudcost
+  # Tabular output methods for the ServerList class
+  module ServerTabularOutput
+    def headings
+      headings = if @options[:summary]
+                   [""]
+                 elsif @options[:group_by]
+                   %w[Group Servers]
+                 else
+                   %w[Name UUID Flavor Tags]
+                 end
+      headings.concat ["vCPU's", "Memory [GB]", "SSD [GB]", "Bulk [GB]", "CHF/day", "CHF/30-days"]
+    end
+
+    def rows
+      rows = []
+      @servers.sort_by(&:name).map do |server|
+        rows << [
+          server.name,
+          server.uuid,
+          server.flavor,
+          server.tags_to_s,
+          server.vcpu_count,
+          server.memory_gb,
+          server.storage_size(:ssd),
+          server.storage_size(:bulk),
+          format("%.2f", server.total_costs_per_day.round(2)),
+          format("%.2f", (server.total_costs_per_day * 30).round(2))
+        ]
+      end
+      rows
+    end
+
+    def totals(servers = @servers)
+      totals = calculate_totals(servers)
+      total_row = @options[:summary] ? %w[Total] : ["Total", "", "", ""]
+      total_row.concat [
+        totals[:vcpu],
+        totals[:memory],
+        totals[:ssd],
+        totals[:bulk],
+        format("%.2f", totals[:cost].round(2)),
+        format("%.2f", (totals[:cost] * 30).round(2))
+      ]
+    end
+
+    def tags_table
+      Terminal::Table.new do |t|
+        t.title = "cloudscale.ch server tags"
+        t.title += " (#{@options[:profile]})" if @options[:profile]
+        t.headings = %w[Name UUID Tags]
+        t.rows = @servers.sort_by(&:name).map do |server|
+          [
+            server.name,
+            server.uuid,
+            server.tags_to_s
+          ]
+        end
+      end
+    end
+
+    def cost_table
+      table = Terminal::Table.new do |t|
+        t.title = "cloudscale.ch server costs"
+        t.title += " (#{@options[:profile]})" if @options[:profile]
+        t.headings = headings
+        t.rows = rows unless @options[:summary]
+      end
+
+      table.add_separator unless @options[:summary]
+      table.add_row totals
+      first_number_row = @options[:summary] ? 1 : 2
+      (first_number_row..table.columns.size).each { |column| table.align_column(column, :right) }
+      table
+    end
+
+    def grouped_cost_table(group_rows)
+      table = Terminal::Table.new do |t|
+        t.title = "cloudscale.ch server costs grouped by tag \"#{@options[:group_by]}\""
+        t.title += " (#{@options[:profile]})" if @options[:profile]
+        t.headings = headings
+      end
+      table.rows = group_rows
+      (1..table.columns.size).each { |column| table.align_column(column, :right) }
+      table
+    end
+  end
+end

data/lib/cloudcost/commands/server.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "server/server_tabular_output"
+require_relative "server/server_influxdb_output"
+require_relative "csv_output"
+require_relative "server/server"
+require_relative "server/server_list"

data/lib/cloudcost/commands/volume/volume.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Cloudcost
+  # Representation of cloudscale.ch volume object
+  class Volume
+    attr_accessor :data
+
+    def initialize(data)
+      @data = data
+    end
+
+    def name
+      @data[:name]
+    end
+
+    def uuid
+      @data[:uuid]
+    end
+
+    def type
+      @data[:type]
+    end
+
+    def servers
+      @data[:servers]
+    end
+
+    def server_name
+      servers.size.positive? ? servers.first[:name] : ""
+    end
+
+    def attached?
+      servers.size.positive?
+    end
+
+    def server_uuids
+      @data[:server_uuids]
+    end
+
+    def tags
+      @data[:tags]
+    end
+
+    def size_gb
+      @data[:size_gb]
+    end
+
+    def tags_to_s
+      Cloudcost.tags_to_s(tags)
+    end
+
+    def costs_per_day
+      Pricing.storage_costs_per_day(type, size_gb)
+    end
+  end
+end

data/lib/cloudcost/commands/volume/volume_influxdb_output.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Cloudcost
+  # InfluxDB output methods for the ServerList class
+  module VolumeInfluxdbOutput
+    def totals_influx_line_protocol
+      lines = []
+      tag_set = [
+        "profile=#{@options[:profile] || "?"}",
+        "state=#{volumes_attached_state}"
+      ]
+      metrics = calculate_totals
+      [
+        { field: "ssd_gb", key: :size_ssd, unit: "i" },
+        { field: "bulk_gb", key: :size_bulk, unit: "i" },
+        { field: "chf_per_day", key: :cost, unit: "" }
+      ].each do |field|
+        lines << %(
+          cloudscaleVolumeCosts,#{tag_set.join(",")}
+          #{field[:field]}=#{metrics[field[:key]]}#{field[:unit]}
+        ).gsub(/\s+/, " ").strip
+      end
+      lines.join("\n")
+    end
+
+    def volumes_attached_state
+      case @options[:attached]
+      when true
+        "attached"
+      when false
+        "unattached"
+      else
+        "all"
+      end
+    end
+  end
+end

data/lib/cloudcost/commands/volume/volume_list.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "terminal-table"
+
+module Cloudcost
+  # volumeList represents a list of volumes and integrates several output methods
+  class VolumeList
+    include Cloudcost::CsvOutput
+    include Cloudcost::VolumeInfluxdbOutput
+
+    def initialize(volumes, options = {})
+      @volumes = volumes
+      @options = options
+    end
+
+    def calculate_totals(volumes = @volumes)
+      total = { size: 0, size_ssd: 0, size_bulk: 0, cost: 0.0 }
+      volumes.each do |volume|
+        total[:size] += volume.size_gb
+        total["size_#{volume.type}".to_sym] += volume.size_gb if %w[ssd bulk].include? volume.type
+        total[:cost] += volume.costs_per_day
+      end
+      total
+    end
+
+    def totals(volumes = @volumes)
+      total = calculate_totals(volumes)
+      total_row = @options[:summary] ? %w[Total] : ["Total", "", "", "", ""]
+      if @options[:summary]
+        total_row.concat [
+          total[:size_ssd],
+          total[:size_bulk],
+          total[:size]
+        ]
+      else
+        total_row.concat [total[:size]]
+      end
+      total_row.concat [
+        format("%.2f", total[:cost].round(2)),
+        format("%.2f", (total[:cost] * 30).round(2))
+      ]
+    end
+
+    def headings
+      headings = if @options[:summary]
+                   ["", "SSD [GB]", "Bulk [GB]", "Total [GB]"]
+                 else
+                   ["Name", "UUID", "Type", "Servers", "Tags", "Size [GB]"]
+                 end
+      headings.concat ["CHF/day", "CHF/30-days"]
+    end
+
+    def rows
+      rows = []
+      @volumes.sort_by(&:name).map do |volume|
+        rows << [
+          volume.name,
+          volume.uuid,
+          volume.type,
+          volume.server_name,
+          volume.tags_to_s,
+          volume.size_gb,
+          format("%.2f", volume.costs_per_day.round(2)),
+          format("%.2f", (volume.costs_per_day * 30).round(2))
+        ]
+      end
+      rows
+    end
+
+    def cost_table
+      table = Terminal::Table.new do |t|
+        t.title = "cloudscale.ch volume costs"
+        t.title += " (#{@options[:profile]})" if @options[:profile]
+        t.headings = headings
+        t.rows = rows unless @options[:summary]
+      end
+
+      table.add_separator unless @options[:summary]
+      table.add_row totals
+      first_number_row = @options[:summary] ? 1 : 2
+      (first_number_row..table.columns.size).each { |column| table.align_column(column, :right) }
+      table
+    end
+  end
+end

data/lib/cloudcost/commands/volume.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "csv_output"
+require_relative "volume/volume"
+require_relative "volume/volume_influxdb_output"
+require_relative "volume/volume_list"

data/lib/cloudcost/error.rb

@@ -6,4 +6,6 @@ module Cloudcost
   class ProfileError < Error; end
 
   class TokenError < Error; end
+
+  class PricingError < StandardError; end
 end

data/lib/cloudcost/pricing.rb

@@ -2,14 +2,12 @@
 
 require "yaml"
 
-PRICING = YAML.load_file( File.join(
-  File.expand_path("../..", __dir__), "data/pricing.yml")
-)
+PRICING = YAML.load_file(File.join(
+                           File.expand_path("../..", __dir__), "data/pricing.yml"
+                         ))
 
 module Cloudcost
-  class PricingError < StandardError
-  end
-
+  # pricing class which implements cost calculation methods for cloudscale.ch resources
   module Pricing
     def self.server_costs_per_day(flavor)
       PRICING["servers"][flavor] || raise(PricingError, "#{flavor} flavor not found in pricing.yml")

data/lib/cloudcost/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cloudcost
-  VERSION = "0.2.0"
+  VERSION = "0.4.1"
 end

data/lib/cloudcost.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require "terminal-table"
 require "csv"
 
 require "cloudcost/version"
+require "cloudcost/error"
 require "cloudcost/api_token"
 require "cloudcost/api_connection"
-require "cloudcost/server"
-require "cloudcost/server_list"
+require "cloudcost/pricing"
+require "cloudcost/commands/server"
+require "cloudcost/commands/volume"
 require "cloudcost/cli"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cloudcost
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Nik Wolfgramm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-17 00:00:00.000000000 Z
+date: 2021-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: excon
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.82.0
+        version: 0.85.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.82.0
+        version: 0.85.0
 - !ruby/object:Gem::Dependency
   name: parseconfig
   requirement: !ruby/object:Gem::Requirement
@@ -80,8 +80,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.3
-description: Calculate cloudscale.ch server costs from your actual deployment
-email: wolfgramm@puzzle.ch
+description: Calculate cloudscale.ch server costs from the current deployment
+email: 
 executables:
 - cloudcost
 extensions: []
@@ -102,10 +102,18 @@ files:
 - lib/cloudcost/api_connection.rb
 - lib/cloudcost/api_token.rb
 - lib/cloudcost/cli.rb
+- lib/cloudcost/commands/csv_output.rb
+- lib/cloudcost/commands/server.rb
+- lib/cloudcost/commands/server/server.rb
+- lib/cloudcost/commands/server/server_influxdb_output.rb
+- lib/cloudcost/commands/server/server_list.rb
+- lib/cloudcost/commands/server/server_tabular_output.rb
+- lib/cloudcost/commands/volume.rb
+- lib/cloudcost/commands/volume/volume.rb
+- lib/cloudcost/commands/volume/volume_influxdb_output.rb
+- lib/cloudcost/commands/volume/volume_list.rb
 - lib/cloudcost/error.rb
 - lib/cloudcost/pricing.rb
-- lib/cloudcost/server.rb
-- lib/cloudcost/server_list.rb
 - lib/cloudcost/version.rb
 homepage: https://gitlab.puzzle.ch/nwolfgramm/cloudcost
 licenses:

data/lib/cloudcost/server_list.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-module Cloudcost
-  class ServerList
-    def initialize(servers, options = {})
-      @servers = servers
-      @options = options
-    end
-
-    def calculate_totals(servers = @servers)
-      totals = { vcpu: 0, memory: 0, ssd: 0, bulk: 0, cost: 0.0 }
-      servers.each do |server|
-        totals[:vcpu] += server.vcpu_count
-        totals[:memory] += server.memory_gb
-        totals[:ssd] += server.storage_size(:ssd)
-        totals[:bulk] += server.storage_size(:bulk)
-        totals[:cost] += server.total_costs_per_day
-      end
-      totals
-    end
-
-    def headings
-      headings = if @options[:summary]
-        [""]
-      elsif @options[:group_by]
-        ["Group",  "Servers"]
-      else
-        %w[Name UUID Flavor Tags]
-      end
-      headings.concat ["vCPU's", "Memory [GB]", "SSD [GB]", "Bulk [GB]", "CHF/day", "CHF/30-days"]
-    end
-
-    def rows
-      rows = []
-      @servers.sort_by(&:name).map do |server|
-        rows << [
-          server.name,
-          server.uuid,
-          server.flavor,
-          server.tags_to_s,
-          server.vcpu_count,
-          server.memory_gb,
-          server.storage_size(:ssd),
-          server.storage_size(:bulk),
-          format("%.2f", server.total_costs_per_day.round(2)),
-          format("%.2f", (server.total_costs_per_day * 30).round(2))
-        ]
-      end
-      rows
-    end
-
-    def totals(servers = @servers)
-      totals = calculate_totals(servers)
-      total_row = @options[:summary] ? %w[Total] : ["Total", "", "", ""]
-      total_row.concat [
-        totals[:vcpu],
-        totals[:memory],
-        totals[:ssd],
-        totals[:bulk],
-        format("%.2f", totals[:cost].round(2)),
-        format("%.2f", (totals[:cost] * 30).round(2))
-      ]
-    end
-
-    def tags_table
-      Terminal::Table.new do |t|
-        t.title = "cloudscale.ch server tags"
-        t.title += " (#{@options[:profile]})" if @options[:profile]
-        t.headings = %w[Name UUID Tags]
-        t.rows = @servers.sort_by(&:name).map do |server|
-          [
-            server.name,
-            server.uuid,
-            server.tags_to_s
-          ]
-        end
-      end
-    end
-
-    def cost_table
-      table = Terminal::Table.new do |t|
-        t.title = "cloudscale.ch server costs"
-        t.title += " (#{@options[:profile]})" if @options[:profile]
-        t.headings = headings
-        t.rows = rows unless @options[:summary]
-      end
-
-      table.add_separator unless @options[:summary]
-      table.add_row totals
-      first_number_row = @options[:summary] ? 1 : 2
-      (first_number_row..table.columns.size).each { |column| table.align_column(column, :right) }
-      table
-    end
-
-    def grouped_cost_table
-      no_tag = "<no-tag>"
-      group_rows = @servers.group_by {|s| s.tags[@options[:group_by].to_sym] || no_tag }.map do |name, servers|
-        server_groups_data(name, servers).values.flatten
-      end.sort {|a, b| a[0] == no_tag ? 1 : a[0] <=> b[0] }
-      if @options[:output] == "csv"
-        CSV.generate do |csv|
-          csv << headings
-          group_rows.each { |row| csv << row }
-        end
-      elsif @options[:output] == "influx"
-        lines = []
-        group_rows.each do |row|
-          [
-            { field: "server_count", position: 1, unit: "i" },
-            { field: "vcpus", position: 2, unit: "i" },
-            { field: "memory_gb", position: 3, unit: "i" },
-            { field: "ssd_gb", position: 4, unit: "i" },
-            { field: "bulk_gb", position: 5, unit: "i" },
-            { field: "chf_per_day", position: 6, unit: "" },
-          ].each do |field| 
-            lines << "cloudscaleServerCosts,group=#{row[0]},profile=#{@options[:profile] || "?"} #{field[:field]}=#{row[field[:position]]}#{field[:unit]}"
-          end
-        end
-        lines.join("\n")
-      else
-        table = Terminal::Table.new do |t|
-          t.title = "cloudscale.ch server costs grouped by tag \"#{@options[:group_by]}\""
-          t.title += " (#{@options[:profile]})" if @options[:profile]
-          t.headings = headings
-        end
-        table.rows = group_rows
-        (1..table.columns.size).each { |column| table.align_column(column, :right) }
-        table
-      end
-    end
-
-    def server_groups_data(name, servers)
-      data = { name: name, count: 0, vcpu: 0, memory: 0, ssd: 0, bulk: 0, costs_daily: 0 }
-      servers.each do |server|
-        data[:count] += 1
-        data[:vcpu] += server.vcpu_count
-        data[:memory] += server.memory_gb
-        data[:ssd] += server.storage_size(:ssd)
-        data[:bulk] += server.storage_size(:bulk)
-        data[:costs_daily] += server.total_costs_per_day
-      end
-      data[:costs_monthly] = (data[:costs_daily] * 30).round(2)
-      data[:costs_daily] = data[:costs_daily].round(2)
-      data
-    end
-
-    def to_csv
-      CSV.generate do |csv|
-        csv << headings
-        if @options[:summary]
-          csv << totals
-        else
-          rows.each { |row| csv << row }
-        end
-      end
-    end
-
-  end
-end