triton-ops 0.18.4.pre

data/lib/triton-ops/resource/virtual_machine/disk.rb

@@ -0,0 +1,123 @@
+
+# -*- ruby -*-
+
+require 'contracts' # BSD-2-Clause License
+
+require_relative '../../support/feature/comparable_as_hash'
+require_relative '../../support/feature/hash_from_initialization_contract'
+require_relative '../../support/types'
+
+module TritonOps
+  module Resource
+    class VirtualMachine
+      class Disk
+        include ::Contracts::Core
+        include ::Contracts::Builtin
+        include ::TritonOps::Support::Feature::ComparableAsHash
+        include ::TritonOps::Support::Feature::HashFromInitializationContract
+        include ::TritonOps::Support::Types
+
+        Media = ::Contracts::Enum[*%w(disk cdrom)]
+        Model = ::Contracts::Enum[*%w(virtio ide scsi)]
+
+        Contract ({
+                    :block_size     => Integer,
+                    :compression    => CompressionAlgorithm,
+                    :media          => Media,
+                    :model          => Model,
+                    :path           => String,
+                    :refreservation => Integer,
+                    :size           => Integer,
+                    :zfs_filesystem => String,
+                    :zpool          => String,
+                    :boot           => Maybe[Bool],
+                    :image_size     => Maybe[Integer],
+                    :image_uuid     => Maybe[String],
+                  }) => Disk
+        def initialize(**options)
+          @options = options
+          self.to_h
+          remove_instance_variable '@options'
+          self
+        end
+
+        #######################
+        # Required Properties #
+        #######################
+
+        Contract None => Integer
+        def block_size
+          @block_size ||= @options.fetch :block_size
+        end
+
+        Contract None => CompressionAlgorithm
+        def compression
+          @compression ||= @options.fetch :compression
+        end
+
+        Contract None => Media
+        def media
+          @media ||= @options.fetch :media
+        end
+
+        Contract None => Model
+        def model
+          @model ||= @options.fetch :model
+        end
+
+        Contract None => String
+        def path
+          @path ||= @options.fetch :path
+        end
+
+        Contract None => Integer
+        def refreservation
+          @refreservation ||= @options.fetch :refreservation
+        end
+
+        Contract None => Integer
+        def size
+          @size ||= @options.fetch :size
+        end
+
+        Contract None => String
+        def zfs_filesystem
+          @zfs_filesystem ||= @options.fetch :zfs_filesystem
+        end
+
+        Contract None => String
+        def zpool
+          @zpool ||= @options.fetch :zpool
+        end
+
+        #######################
+        # Optional Properties #
+        #######################
+
+        Contract None => Maybe[Bool]
+        def boot
+          @boot ||= (@options || {}).fetch(:boot, nil)
+        end
+
+        Contract None => Maybe[Integer]
+        def image_size
+          @image_size ||= (@options || {}).fetch(:image_size, nil)
+        end
+
+        Contract None => Maybe[String]
+        def image_uuid
+          @image_uuid ||= (@options || {}).fetch(:image_uuid, nil)
+        end
+
+        #######################
+        # Convenience Methods #
+        #######################
+
+        Contract None => Bool
+        def image?
+          image_uuid ? true : false
+        end
+      end
+    end
+  end
+end

data/lib/triton-ops/resource/virtual_machine/network_interface.rb

@@ -0,0 +1,119 @@
+
+# -*- ruby -*-
+
+require 'contracts' # BSD-2-Clause License
+
+require_relative '../../support/feature/comparable_as_hash'
+require_relative '../../support/feature/hash_from_initialization_contract'
+require_relative '../../support/types'
+
+module TritonOps
+  module Resource
+    class VirtualMachine
+      class NetworkInterface
+        include ::Contracts::Core
+        include ::Contracts::Builtin
+        include ::TritonOps::Support::Feature::ComparableAsHash
+        include ::TritonOps::Support::Feature::HashFromInitializationContract
+        include ::TritonOps::Support::Types
+
+        Model = ::Contracts::Enum[*%w(virtio e1000 rtl8139)]
+
+        Contract ({
+                    :interface    => String,
+                    :ip           => String,
+                    :ips          => ArrayOf[String],
+                    :mac          => String,
+                    :nic_tag      => String,
+                    :gateway      => Maybe[String],
+                    :gateways     => Maybe[ArrayOf[String]],
+                    :model        => Maybe[Model],
+                    :mtu          => Maybe[Integer],
+                    :netmask      => Maybe[String],
+                    :network_uuid => Maybe[String],
+                    :primary      => Maybe[Bool],
+                    :vlan_id      => Maybe[Integer],
+                  }) => NetworkInterface
+        def initialize(**options)
+          @options = options
+          self.to_h
+          remove_instance_variable '@options'
+          self
+        end
+
+        #######################
+        # Required Properties #
+        #######################
+
+        Contract None => String
+        def interface
+          @interface ||= @options.fetch :interface
+        end
+
+        Contract None => String
+        def ip
+          @ip ||= @options.fetch :ip
+        end
+
+        Contract None => ArrayOf[String]
+        def ips
+          @ips ||= @options.fetch :ips
+        end
+
+        Contract None => String
+        def mac
+          @mac ||= @options.fetch :mac
+        end
+
+        Contract None => String
+        def nic_tag
+          @nic_tag ||= @options.fetch :nic_tag
+        end
+
+        #######################
+        # Optional Properties #
+        #######################
+
+        Contract None => Maybe[String]
+        def gateway
+          @gateway ||= (@options || {}).fetch(:gateway, nil)
+        end
+
+        Contract None => ArrayOf[String]
+        def gateways
+          @gateways ||= @options.fetch(:gateways, [])
+        end
+
+        Contract None => Maybe[Model]
+        def model
+          @model ||= (@options || {}).fetch(:model, nil)
+        end
+
+        Contract None => Maybe[Integer]
+        def mtu
+          @mtu ||= (@options || {}).fetch(:mtu, nil)
+        end
+
+        Contract None => Maybe[String]
+        def netmask
+          @netmask ||= (@options || {}).fetch(:netmask, nil)
+        end
+
+        Contract None => Maybe[String]
+        def network_uuid
+          @network_uuid ||= (@options || {}).fetch(:network_uuid, nil)
+        end
+
+        Contract None => Maybe[Bool]
+        def primary
+          @primary ||= (@options || {}).fetch(:primary, nil)
+        end
+
+        Contract None => Maybe[Integer]
+        def vlan_id
+          @vlan_id ||= (@options || {}).fetch(:vlan_id, nil)
+        end
+      end
+    end
+  end
+end

data/lib/triton-ops/resource/vm.rb

@@ -0,0 +1,14 @@
+
+# -*- ruby -*-
+
+require_relative 'virtual_machine'
+
+module TritonOps
+  module Resource
+    module VM
+      def self.new(**options)
+        TritonOps::Resource::VirtualMachine.new options
+      end
+    end
+  end
+end

data/lib/triton-ops/resources.rb

@@ -0,0 +1,11 @@
+
+# -*- ruby -*-
+
+require_relative 'resource/image'
+require_relative 'resource/platform'
+require_relative 'resource/server'
+require_relative 'resource/user'
+require_relative 'resource/virtual_machine'
+require_relative 'resource/virtual_machine/disk'
+require_relative 'resource/virtual_machine/network_interface'
+require_relative 'resource/vm'

data/lib/triton-ops/snapshot.rb

@@ -0,0 +1,56 @@
+
+# -*- ruby -*-
+
+require 'contracts' # BSD-2-Clause License
+require 'redis'     # MIT License
+require 'json'      # Ruby Standard Library
+
+require_relative 'support/type_coercion'
+require_relative 'resources'
+
+module TritonOps
+  class Snapshot
+    include ::Contracts::Core
+    include ::Contracts::Builtin
+    include ::TritonOps::Support::TypeCoercion
+
+    def initialize(headnode, timestamp, **options)
+      @headnode  = headnode
+      @timestamp = Coerce.to_time timestamp
+      @namespace = options.fetch(:namespace) { '' }
+      self
+    end
+
+    attr_reader :headnode, :timestamp
+
+    def prefix
+      @prefix ||= "#{@namespace}/headnode/#{headnode}/snapshot/#{timestamp.iso8601}"
+    end
+
+    def array_from_json_at_redis_prefix
+      raise TypeError unless type = ::TritonOps::Resource.constants.find { |name| name.to_s.downcase == __callee__.to_s.chop }
+
+      if instance_variable_defined? "@#{__callee__}"
+        instance_variable_get "@#{__callee__}"
+      else
+        instance_variable_set(
+          "@#{__callee__}",
+            JSON.parse(
+              (redis.get("#{prefix}/#{__callee__}") || '[]'),
+              symbolize_names: true).map { |spec| ::TritonOps::Resource.const_get(type).new spec })
+      end
+    end
+
+    alias images    array_from_json_at_redis_prefix
+    alias platforms array_from_json_at_redis_prefix
+    alias servers   array_from_json_at_redis_prefix
+    alias users     array_from_json_at_redis_prefix
+    alias vms       array_from_json_at_redis_prefix
+
+    private
+
+    def redis
+      @redis ||= Redis.new
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+
+# -*- ruby -*-
+
+require 'redis' # MIT License
+require_relative '../snapshot'
+
+module TritonOps
+  class Snapshot
+    class Catalog
+      def initialize(**options)
+        @namespace = options.fetch(:namespace) { '' }
+        self
+      end
+
+      attr_accessor :namespace
+
+      def headnodes
+        redis.smembers("#{namespace}/headnodes") || []
+      end
+
+      def snapshots(headnode)
+        return [] unless headnodes.include? headnode
+        redis.smembers("#{namespace}/headnode/#{headnode}/snapshots") || []
+      end
+
+      def properties(headnode, snapshot)
+        return [] unless snapshots(headnode).include? snapshot
+        redis.smembers("#{namespace}/headnode/#{headnode}/snapshot/#{snapshot}") || []
+      end
+
+      def get(headnode, snapshot, property = :all)
+        TritonOps::Snapshot.new headnode, snapshot, namespace: @namespace
+      end
+
+      private
+
+      def redis
+        @redis ||= Redis.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+
+# -*- ruby -*-
+
+require 'contracts' # BSD-2-Clause License
+require 'json'      # Ruby Standard Library
+require 'redis'     # MIT License
+require 'time'      # Ruby Standard Library
+
+module TritonOps
+  class Snapshot
+    class Collector
+      include ::Contracts::Core
+      include ::Contracts::Builtin
+
+      Contract String, KeywordArgs[namespace: Optional[String]] => Collector
+      def initialize(headnode, **options)
+        @headnode  = headnode
+        @namespace = options.fetch(:namespace) { '' }
+        self
+      end
+
+      attr_reader   :headnode
+      attr_accessor :namespace
+
+      COMMANDS = {
+        images:    %q(/opt/smartdc/bin/sdc-imgadm list --json),
+        platforms: %q(/opt/smartdc/bin/sdcadm platform list --json),
+        servers:   %q(/opt/smartdc/bin/sdc-server lookup -j),
+        timestamp: %q(/usr/xpg4/bin/date +%s),
+        users:     %q(/opt/smartdc/bin/sdc-useradm search --json 'uuid=*'),
+        vms:       %q(/opt/smartdc/bin/sdc-vmadm list --json),
+      }
+
+      TARGETS = COMMANDS.keys - %i(timestamp)
+
+      Contract RespondTo[:to_s], String => Any
+      def record(key, value)
+        snapshot = timestamp.iso8601
+        redis.multi do
+          redis.set   "#{namespace}/headnode/#{headnode}/snapshot/#{snapshot}/#{key}", value
+          redis.sadd  "#{namespace}/headnode/#{headnode}/snapshot/#{snapshot}", key
+          redis.sadd "#{namespace}/headnode/#{headnode}/snapshots", snapshot
+          redis.sadd  "#{namespace}/headnodes", headnode
+        end
+      end
+
+      Contract RespondTo[:to_s], Any => Any
+      def record(key, value)
+        record key, JSON.dump(value)
+      end
+
+      # Most of the commands we need to execute output a JSON array.
+      def array_from_json_output_of_remote_command
+        if instance_variable_defined? "@#{__callee__}"
+          instance_variable_get "@#{__callee__}"
+        else
+          instance_variable_set(
+            "@#{__callee__}",
+            JSON.parse(execute_remote!(command(__callee__))))
+        end
+      end
+
+      alias images    array_from_json_output_of_remote_command
+      alias platforms array_from_json_output_of_remote_command
+      alias servers   array_from_json_output_of_remote_command
+      alias users     array_from_json_output_of_remote_command
+      alias vms       array_from_json_output_of_remote_command
+
+      # This one needs special handling, since it outputs one JSON object per line.
+      def servers
+        @servers ||= execute_remote!(command(:servers)).each_line.map { |line| JSON.parse line }
+      end
+
+      # This one needs special handling, since there is no JSON involved.
+      Contract None => Time
+      def timestamp
+        @timestamp ||= Time.at(
+          execute_remote!(command(:timestamp)).to_i).utc
+      end
+
+      private
+
+      def command(target)
+        COMMANDS.fetch target
+      end
+
+      def execute_remote!(command)
+        %x(ssh #{headnode} -- #{command})
+      end
+
+      def redis
+        @redis ||= Redis.new
+      end
+    end
+  end
+end