triton-ops 0.18.4.pre

data/lib/triton-ops/snapshot/explorer.rb

@@ -0,0 +1,70 @@
+
+# -*- ruby -*-
+
+require 'redis'      # MIT License
+require 'tty-prompt' # MIT License
+require_relative 'catalog'
+
+module TritonOps
+  class Snapshot
+    class Explorer
+      def initialize(**options)
+        @namespace = options.fetch(:namespace) { '' }
+        self
+      end
+
+      def headnode
+        return unless headnodes?
+        prompt.select 'Which headnode?', catalog.headnodes
+      end
+
+      def snapshot(headnode)
+        return unless snapshots? headnode
+        prompt.select 'Which snapshot?', catalog.snapshots(headnode)
+      end
+
+      def browse
+        h = headnode
+        s = snapshot h
+        [h, s]
+      end
+
+      private
+
+      def fatal(message, status = 1)
+        error message
+        exit status
+      end
+
+      def error(message)
+        pastel.red message
+      end
+
+      def headnodes?
+        not catalog.headnodes.empty?
+      end
+
+      def snapshots?(headnode)
+        not catalog.snapshots(headnode).empty?
+      end
+
+      def pastel
+        @pastel ||= Pastel.new
+      end
+
+      def catalog
+        @catalog ||= Catalog.new namespace: @namespace
+      end
+
+      def prompt
+        @prompt ||= ::TTY::Prompt.new
+      end
+
+      def redis
+        @redis ||= ::Redis.new
+      end
+    end
+  end
+end
+
+E = TritonOps::Snapshot::Explorer.new

data/lib/triton-ops/snapshot/reporter.rb

@@ -0,0 +1,99 @@
+
+# -*- ruby -*-
+
+require 'contracts' # BSD-2-Clause License
+require 'tty-table' # MIT License
+
+require_relative '../snapshot'
+
+module TritonOps
+  class Snapshot
+    class Reporter
+      include ::Contracts::Core
+      include ::Contracts::Builtin
+
+      Format = Enum[*%i(basic ascii unicode)]
+
+      Contract ::TritonOps::Snapshot, KeywordArgs[
+        :exclude => Optional[ArrayOf[String]],
+        :format  => Optional[Format],
+        :targets => Optional[ArrayOf[String]],
+      ] => Reporter
+      def initialize(snapshot, **options)
+        @snapshot = snapshot
+        @options  = options
+        self
+      end
+
+      Contract None => Any
+      def usage
+        users.each do |user|
+          uuid  = user.uuid
+          ram   = memory(uuid)  || 0
+          disk  = storage(uuid) || 0
+          next if [ram, disk].all?(&:zero?)
+
+          login = user.login
+          cn    = user.cn
+
+          puts "# #{login} (#{cn}) has (#{ram} MB of Memory) and (#{disk} MB of Storage) reserved"
+
+          puts TTY::Table.new(
+                 header: ['VM Alias', 'Memory', 'Storage', 'Creation Date'],
+                 rows: owned_by(uuid)
+                   .sort_by { |vm| vm.create_timestamp }
+                   .map do |vm|
+                   [
+                     vm.alias,
+                     vm.max_physical_memory,
+                     (vm.disks ? vm.disks.map { |disk| disk.size }.reduce(:+) : 0),
+                     vm.create_timestamp.iso8601
+                   ]
+                 end).render(format)
+        end
+      end
+
+      private
+
+      def format
+        @options.fetch(:format) { :basic }
+      end
+
+      def exclusions
+        @options.fetch(:exclude) { [] }
+      end
+
+      def targets
+        @options.fetch(:targets) { @snapshots.users.map { |user| user.login } }
+      end
+
+      def users
+        @snapshot.users
+          .reject { |user| exclusions.include? user.login }
+          .reject { |user| @snapshot.vms.none? { |vm| vm.owner_uuid == user.uuid } }
+          .select { |user| targets.empty? or targets.include?(user.login) }
+      end
+
+      def owned_by(owner_uuid)
+        @snapshot
+          .vms
+          .select { |vm| vm.owner_uuid == owner_uuid }
+      end
+
+      def memory(owner_uuid)
+        owned_by(owner_uuid)
+          .map { |vm| vm.max_physical_memory }
+          .reduce(:+)
+      end
+
+      def storage(owner_uuid)
+        owned_by(owner_uuid)
+          .reject { |vm| vm.disks.empty? }
+          .map { |vm| vm.disks
+                   .map { |disk| disk.size }
+                   .reduce(:+) }
+          .reduce(:+)
+      end
+    end
+  end
+end

data/lib/triton-ops/snapshots.rb

@@ -0,0 +1,8 @@
+
+# -*- ruby -*-
+
+require_relative 'snapshot'
+require_relative 'snapshot/catalog'
+require_relative 'snapshot/collector'
+require_relative 'snapshot/explorer'
+require_relative 'snapshot/reporter'

data/lib/triton-ops/support/feature/comparable_as_hash.rb

@@ -0,0 +1,14 @@
+
+# -*- ruby -*-
+
+module TritonOps
+  module Support
+    module Feature
+      module ComparableAsHash
+        def ==(other)
+          (other.respond_to?(:to_h) && (self.to_h == other.to_h)) || false
+        end
+      end
+    end
+  end
+end

data/lib/triton-ops/support/feature/hash_from_initialization_contract.rb

@@ -0,0 +1,25 @@
+
+# -*- ruby -*-
+
+require 'contracts' # BSD-2-Clause License
+
+module TritonOps
+  module Support
+    module Feature
+      module HashFromInitializationContract
+        include ::Contracts::Core
+
+        def to_h
+          self.class.__contracts_engine
+            .decorated_methods_for(:instance_methods, :initialize)
+            .flat_map(&:args_contracts)
+            .flat_map(&:keys)
+            .map    { |k| [k, public_send(k)] }
+            .reject { |_, v| v.nil? }
+            .map    { |k, v| [k, (v.respond_to?(:iso8601) ? v.iso8601 : v)] }
+            .to_h
+        end
+      end
+    end
+  end
+end

data/lib/triton-ops/support/type_coercion.rb

@@ -0,0 +1,70 @@
+
+# -*- ruby -*-
+
+require 'contracts' # BSD-2-Clause License
+require 'date'      # Ruby Standard Library
+require 'time'      # Ruby Standard Library
+
+module TritonOps
+  module Support
+    module TypeCoercion
+      module Coerce
+        include ::Contracts::Core
+        include ::Contracts::Builtin
+
+        Contract String => Time
+        def self.to_time(string)
+          if string =~ /^[[:digit:]]+$/
+            self.to_time string.chars.take(10).join.to_i
+          else
+            Time.parse(string).utc
+          end
+        end
+
+        Contract Integer => Time
+        def self.to_time(integer)
+          if integer.digits.length > 10
+            self.to_time integer.to_s
+          else
+            Time.at(integer).utc
+          end
+        end
+
+        Contract DateTime => Time
+        def self.to_time(datetime)
+          datetime.to_time
+        end
+
+        Contract Time => Time
+        def self.to_time(time)
+          time
+        end
+
+        Contract Enum[%w(true false)] => Bool
+        def self.to_bool(string)
+          case string
+          when 'true'
+            true
+          when 'false'
+            false
+          end
+        end
+
+        Contract Bool => Bool
+        def self.to_bool(bool)
+          bool
+        end
+
+        Contract Time => String
+        def self.to_string(time)
+          time.utc.iso8601
+        end
+
+        Contract RespondTo[:to_s] => String
+        def self.to_string(object)
+          object.to_s
+        end
+      end
+    end
+  end
+end

data/lib/triton-ops/support/types.rb

@@ -0,0 +1,20 @@
+
+# -*- ruby -*-
+
+require 'contracts' # BSD-2-Clause License
+require 'date'      # Ruby Standard Library
+require 'time'      # Ruby Standard Library
+
+module TritonOps
+  module Support
+    module Types
+      module Castable
+        Time   = ::Contracts::Or[::String, ::Integer, ::DateTime, ::Time]
+        Bool   = ::Contracts::Or[::Contracts::Enum[*%w(true false)], ::TrueClass, ::FalseClass]
+        String = ::Contracts::RespondTo[:to_s]
+      end
+
+      CompressionAlgorithm = ::Contracts::Enum[*(%w(on off gzip lz4 lzjb zle) + (1..9).map { |n| "gzip-#{n}" })]
+    end
+  end
+end

data/tests/exercise

@@ -0,0 +1,70 @@
+#! /usr/bin/env ruby
+# -*- ruby -*-
+
+require_relative '../lib/triton-ops/snapshot/explorer'
+
+#############
+# Constants #
+#############
+
+SUCCESS = 0
+
+########################
+# Environment Handling #
+########################
+
+feature = {
+  interactive: ENV.fetch('INTERACTIVE') { STDIN.tty? } != 'false',
+  namespace:   ENV.fetch('NAMESPACE')   { '' },
+}
+
+#####################
+# Argument Handling #
+#####################
+
+begin
+  interactive = ::TritonOps::Snapshot::Explorer.new namespace: feature[:namespace]
+  headnode    = ARGV.shift || (interactive.headnode          if feature[:interactive])
+  timestamp   = ARGV.shift || (interactive.snapshot headnode if feature[:interactive])
+rescue Interrupt, TTY::Reader::InputInterrupt
+  exit Errno::EINTR::Errno
+end
+
+#################
+# Sanity Checks #
+#################
+
+exit Errno::EINVAL::Errno if [headnode, timestamp].any?(&:nil?)
+
+################
+# Main Program #
+################
+
+# Where possible, the library provides Contracts for public interfaces. If a
+# suitable Contract cannot be provided, then devising a sensible test is likely
+# difficult.
+
+# First, we begin with a Snapshot:
+
+SNAPSHOT = TritonOps::Snapshot.new headnode, timestamp
+
+# Then, for each major property of the snapshot, we convert each instance of a
+# given type into a Hash, which implicitly validates all return Contracts.
+#
+# Each Hash is then used to instantiate a new Object of the original type,
+# implicitly validating the initialization Contract.
+
+SNAPSHOT.images.map(&:to_h).map    { |image|    ::TritonOps::Resource::Image.new image       }
+SNAPSHOT.platforms.map(&:to_h).map { |platform| ::TritonOps::Resource::Platform.new platform }
+SNAPSHOT.servers.map(&:to_h).map   { |server|   ::TritonOps::Resource::Server.new server     }
+SNAPSHOT.users.map(&:to_h).map     { |user|     ::TritonOps::Resource::User.new user         }
+SNAPSHOT.vms.map(&:to_h).map       { |vm|       ::TritonOps::Resource::VirtualMachine.new vm }
+
+# In a few cases, retrieval is slightly difference, but the concept is the same.
+
+SNAPSHOT.vms.flat_map(&:disks).map(&:to_h).map { |disk| ::TritonOps::Resource::VirtualMachine::Disk.new disk }
+SNAPSHOT.vms.flat_map(&:nics).map(&:to_h).map  { |nic|  ::TritonOps::Resource::VirtualMachine::NetworkInterface.new nic }
+
+# If we've made it this far, all Contracts have passed.
+
+exit SUCCESS

data/tests/run

@@ -0,0 +1,70 @@
+#! /usr/bin/env ruby
+# -*- ruby -*-
+
+require_relative '../lib/triton-ops/snapshot/explorer'
+
+#############
+# Constants #
+#############
+
+SUCCESS = 0
+
+########################
+# Environment Handling #
+########################
+
+feature = {
+  interactive: ENV.fetch('INTERACTIVE') { STDIN.tty? } != 'false',
+  namespace:   ENV.fetch('NAMESPACE')   { '' },
+}
+
+#####################
+# Argument Handling #
+#####################
+
+begin
+  interactive = ::TritonOps::Snapshot::Explorer.new namespace: feature[:namespace]
+  headnode    = ARGV.shift || (interactive.headnode          if feature[:interactive])
+  timestamp   = ARGV.shift || (interactive.snapshot headnode if feature[:interactive])
+rescue Interrupt, TTY::Reader::InputInterrupt
+  exit Errno::EINTR::Errno
+end
+
+#################
+# Sanity Checks #
+#################
+
+exit Errno::EINVAL::Errno if [headnode, timestamp].any?(&:nil?)
+
+################
+# Main Program #
+################
+#
+# Where possible, the library provides Contracts for public interfaces. If a
+# suitable Contract cannot be provided, then devising a sensible test is likely
+# difficult.
+#
+# First, we begin with a Snapshot:
+
+SNAPSHOT = TritonOps::Snapshot.new headnode, timestamp
+
+# Then, for each major property of the snapshot, we convert each instance of a
+# given type into a Hash, which implicitly validates all return Contracts.
+#
+# Each Hash is then used to instantiate a new Object of the original type,
+# implicitly validating the initialization Contract.
+
+SNAPSHOT.images.map(&:to_h).map    { |image|    ::TritonOps::Resource::Image.new image       }
+SNAPSHOT.platforms.map(&:to_h).map { |platform| ::TritonOps::Resource::Platform.new platform }
+SNAPSHOT.servers.map(&:to_h).map   { |server|   ::TritonOps::Resource::Server.new server     }
+SNAPSHOT.users.map(&:to_h).map     { |user|     ::TritonOps::Resource::User.new user         }
+SNAPSHOT.vms.map(&:to_h).map       { |vm|       ::TritonOps::Resource::VirtualMachine.new vm }
+
+# In a few cases, retrieval is slightly difference, but the concept is the same.
+
+SNAPSHOT.vms.flat_map(&:disks).map(&:to_h).map { |disk| ::TritonOps::Resource::VirtualMachine::Disk.new disk }
+SNAPSHOT.vms.flat_map(&:nics).map(&:to_h).map  { |nic|  ::TritonOps::Resource::VirtualMachine::NetworkInterface.new nic }
+
+# If we've made it this far, all Contracts have passed.
+
+exit SUCCESS