vcloud-core 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+/Gemfile.lock
+/coverage/

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+if ENV['VCLOUD_TOOLS_DEV_FOG_MASTER']
+  gem 'fog', :git => 'git@github.com:fog/fog.git', :branch => 'master'
+elsif ENV['VCLOUD_TOOLS_DEV_FOG_LOCAL']
+  gem 'fog', :path => '../fog'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 HM Government (Government Digital Service)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,103 @@
+# VCloud Core
+
+VCloud Core is a gem that supports automatated provisioning of VMWare vCloud Director. It uses Fog under the hood. Primarily developed to support [VCloud Walker](https://github.com/alphagov/vcloud-walker) and [VCloud Tools](https://github.com/alphagov/vcloud-tools).
+
+VCloud Core includes VCloud Query and a command-line wrapper for VCloud Query.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'vcloud-core'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vcloud-core
+
+## Usage
+
+TODO
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## VCloud Query
+
+### Get results from the vCloud Query API
+
+VCloud Query is a light wrapper around the vCloud Query API.
+
+Any, or all, records of a particular 'type' can be returned. These types map to 
+entities in the vCloud system itself, eg: 'vm', 'vApp', 'orgVdc', 'edgeGateway'.
+
+Filters can be applied, using a simple query syntax. See below for basic usage and
+examples.
+
+Run with no arguments, it outputs a list of potential entity types to query, along
+with the potential record types to display (default 'records')
+
+#### Usage:
+
+    vcloud-query [options] [queriable type]
+
+    where [queriable type] maps to a vcloud entity type, eg: vApp, vm, orgVdc
+
+#### Examples:
+
+NB: examples assume FOG_CREDENTIAL has been set accordingly.
+
+    # Get a list of vApps, in YAML
+    vcloud-query -o yaml vApp
+
+    # Get general usage info
+    vcloud-query --help
+
+    # Get a list of all queriable types (left column)
+    vcloud-query
+
+    # Get all VMs with VMware Tools less than 9282, that are not a vApp Template:
+    vcloud-query --filter 'vmToolsVersion=lt=9282;isVAppTemplate==false' vm
+
+#### Supports:
+
+* Returning a list of queriable types (eg vm, vApp, edgeGateway) from the API
+* Displaying all vCloud entities of a given type
+* Filtering the results of the query based on common parameters such as:
+  * entity name
+  * metadata values
+  * key entity parameters
+* Limiting the output to certain fields (eg: name, vmToolsVersion)
+* Returning results in TSV, CSV, and YAML
+
+#### Query Syntax:
+
+Summary of filter query syntax:
+
+    attribute==value                      # == to check equality
+    attribute!=value                      # != to check inequality
+    attribute=lt=value                    # =lt= less than (=le= for <=)
+    attribute=gt=value                    # =gt= greater than (=ge= for >=)
+    attribute==value;attribute2==value2   # ; == AND
+    attribute==value,attribute2==value2   # , == OR
+
+Parentheses can be used to group sub-queries.
+
+**Do not use spaces in the query**
+
+Entity metadata queries have their own subsyntax incorporating the value types:
+
+    metadata:key1==STRING:value1
+    metadata:key1=le=NUMBER:15
+    metadata:key1=gt=DATETIME:2012-06-18T12:00:00-05:00
+
+See http://pubs.vmware.com/vcd-51/topic/com.vmware.vcloud.api.doc_51/GUID-4FD71B6D-6797-4B8E-B9F0-618F4ACBEFAC.html for details.
+

data/Rakefile

@@ -0,0 +1,18 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  # Set a bogus Fog credential, otherwise it's possible for the unit
+  # tests to accidentially run (and succeed against!) an actual
+  # environment, if Fog connection is not stubbed correctly.
+  ENV['FOG_CREDENTIAL'] = 'random_nonsense_owiejfoweijf'
+  task.pattern = FileList['spec/vcloud/**/*_spec.rb']
+end
+
+task :default => [:spec]
+
+require "gem_publisher"
+task :publish_gem do |t|
+  gem = GemPublisher.publish_if_updated("vcloud-core.gemspec", :rubygems)
+  puts "Published #{gem}" if gem
+end

data/bin/vcloud-query

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'optparse'
+require 'methadone'
+
+require 'vcloud/core'
+
+class App
+
+  include Methadone::Main
+  include Methadone::CLILogging
+  include Vcloud
+
+  main do |type|
+    Query.new(type, options).run
+  end
+
+  on('-A', '--sort-asc', '=ATTRIBUTE', 'Sort ascending') do |v|
+    options[:sortAsc] = v
+  end
+
+  on('-D', '--sort-desc', '=ATTRIBUTE', 'Sort descending') do |v|
+    options[:sortDesc] = v
+  end
+
+  on('--fields', '=NAMES', 'Attribute or metadata key names') do |v|
+    options[:fields] = v
+  end
+
+  on('--format', '=ATTRIBUTE', 'Data format to retrieve: records, idrecords, references') do |v|
+    options[:format] = v
+  end
+
+  on('--filter', '=FILTER', 'Filter expression') do |v|
+    options[:filter] = v
+  end
+
+  on('-o', '--output-format', '=FORMAT', 'Output format: csv, tsv, yaml') do |v|
+    options[:output_format] = v.downcase
+  end
+
+  on("--mock",    "Fog Mock mode")
+  on("--verbose", "Verbose output")
+  on("--debug",   "Debugging output")
+
+  arg :type, :optional
+
+  description '
+  vcloud-query takes a query type and returns all vCloud entities of
+  that type, obeying supplied filter rules.
+
+  Query types map to vCloud entities, for example: vApp, vm, orgVdc, orgVdcNetwork.
+
+  Without a type argument, returns a list of available Entity Types to query.
+
+  See https://github.com/alphagov/vcloud-tools/blob/master/README.md for more info.
+
+  Example use:
+
+    # get a list of all vApps, returning all available parameters, in YAML
+
+    vcloud-query -o yaml vApp
+
+    # get a list of all powered off VMs return the name and containerName (vapp
+    # name)
+
+    vcloud-query --filter "status==POWERED_OFF" --fields name,containerName vm
+
+    # list all query types (types are left-most column, possible formats listed
+    # on the left (records is default, and most useful)
+
+    vcloud-query
+
+  '
+
+
+  version Vcloud::Core::VERSION
+
+  #use_log_level_option
+
+  go!
+end

data/jenkins.sh

@@ -0,0 +1,10 @@
+#!/bin/bash -x
+set -e
+
+rm -f Gemfile.lock
+git clean -fdx
+
+bundle install --path "${HOME}/bundles/${JOB_NAME}"
+
+bundle exec rake
+bundle exec rake publish_gem

data/lib/vcloud/core.rb

@@ -0,0 +1,23 @@
+require 'open3'
+require 'vcloud/fog'
+
+require 'vcloud/core/entity'
+require 'vcloud/core/metadata_helper'
+require 'vcloud/core/compute_metadata'
+require 'vcloud/core/vdc'
+require 'vcloud/core/edge_gateway'
+require 'vcloud/core/vm'
+require 'vcloud/core/vapp'
+require 'vcloud/core/vapp_template'
+require 'vcloud/core/org_vdc_network'
+require 'vcloud/core/query'
+
+module Vcloud
+  module Core
+
+    def self.logger
+      @logger ||=Logger.new(STDOUT)
+    end
+
+  end
+end

data/lib/vcloud/core/compute_metadata.rb

@@ -0,0 +1,13 @@
+module Vcloud
+  module Core
+    module ComputeMetadata
+
+        def get_metadata id
+          vcloud_compute_metadata =  Vcloud::Fog::ServiceInterface.new.get_vapp_metadata(id)
+          MetadataHelper.extract_metadata(vcloud_compute_metadata[:MetadataEntry])
+        end
+
+    end
+  end
+end
+

data/lib/vcloud/core/edge_gateway.rb

@@ -0,0 +1,46 @@
+module Vcloud
+  module Core
+    class EdgeGateway
+
+      attr_reader :id
+
+      def initialize(id)
+        unless id =~ /^[-0-9a-f]+$/
+          raise "EdgeGateway id : #{id} is not in correct format"
+        end
+        @id = id
+      end
+
+      def self.get_ids_by_name(name)
+        q = Query.new('edgeGateway', :filter => "name==#{name}")
+        unless res = q.get_all_results
+          raise "Error finding edgeGateway by name #{name}"
+        end
+        res.collect do |record| 
+          record[:href].split('/').last if record.key?(:href)
+        end
+      end
+
+      def self.get_by_name(name)
+        ids = self.get_ids_by_name(name)
+        raise "edgeGateway #{name} not found" if ids.size == 0
+        raise "edgeGateway #{name} is not unique" if ids.size > 1
+        return self.new(ids.first)
+      end
+
+      def vcloud_attributes
+        fsi = Vcloud::Fog::ServiceInterface.new
+        fsi.get_edge_gateway(id)
+      end
+
+      def href
+        vcloud_attributes[:href]
+      end
+
+      def name
+        vcloud_attributes[:name]
+      end
+
+    end
+  end
+end

data/lib/vcloud/core/entity.rb

@@ -0,0 +1,23 @@
+module Vcloud
+  module Core
+    class Entity
+
+      def id_prefix;
+        raise 'id_prefix : method missing'
+      end
+
+      def id
+        raise 'id not found' unless @vcloud_attributes && @vcloud_attributes[:href]
+        extracted_id = @vcloud_attributes[:href].split('/').last
+        unless extracted_id =~ /^#{id_prefix}-[-0-9a-f]+$/
+          raise "#{id_prefix} id : #{extracted_id} is not in correct format"
+        end
+        extracted_id
+      end
+
+      def name
+        @vcloud_attributes[:name]
+      end
+    end
+  end
+end

data/lib/vcloud/core/metadata_helper.rb

@@ -0,0 +1,29 @@
+module Vcloud
+  module Core
+    module MetadataHelper
+
+      def extract_metadata vcloud_metadata_entries
+        metadata = {}
+        vcloud_metadata_entries.each do |entry|
+          next unless entry[:type] == Vcloud::Fog::ContentTypes::METADATA
+          key = entry[:Key].to_sym
+          val = entry[:TypedValue][:Value]
+          case entry[:TypedValue][:xsi_type]
+            when Fog::MetadataValueType::Number
+              val = val.to_i
+            when Fog::MetadataValueType::String
+              val = val.to_s
+            when Fog::MetadataValueType::DateTime
+              val = DateTime.parse(val)
+            when Fog::MetadataValueType::Boolean
+              val = val == 'true' ? true : false
+          end
+          metadata[key] = val
+        end
+        metadata
+      end
+
+      module_function :extract_metadata
+    end
+  end
+end

data/lib/vcloud/core/org_vdc_network.rb

@@ -0,0 +1,102 @@
+module Vcloud
+  module Core
+    class OrgVdcNetwork
+
+      attr_reader :id
+
+      def initialize(id)
+        unless id =~ /^[-0-9a-f]+$/
+          raise "orgVdcNetwork id : #{id} is not in correct format"
+        end
+        @id = id
+      end
+
+      def self.provision(config)
+        raise "Must specify a name" unless name = config[:name]
+        raise "Must specify a vdc_name" unless vdc_name = config[:vdc_name]
+
+        unless config[:fence_mode] == 'isolated' || config[:fence_mode] == 'natRouted'
+          raise "fence_mode #{config[:fence_mode]} not supported. Must be 'isolated' or 'natRouted'"
+        end
+
+        config[:is_shared] = false unless config[:is_shared]
+
+        if config[:fence_mode] == 'natRouted'
+          raise "Must specify an edge_gateway to connect to" unless config.key?(:edge_gateway)
+          edgegw = Vcloud::Core::EdgeGateway.get_by_name(config[:edge_gateway])
+        end
+
+        vdc = Vcloud::Core::Vdc.get_by_name(vdc_name)
+
+        options = construct_network_options(config)
+        options[:EdgeGateway] = { :href => edgegw.href } if edgegw
+
+        begin
+          Vcloud::Core.logger.info("Provisioning new OrgVdcNetwork #{name} in vDC '#{vdc_name}'")
+          attrs = Vcloud::Fog::ServiceInterface.new.post_create_org_vdc_network(vdc.id, name, options)
+        rescue RuntimeError => e
+          Vcloud::Core.logger.error("Could not provision orgVdcNetwork: #{e.message}")
+        end
+
+        raise "Did not successfully create orgVdcNetwork" unless attrs && attrs.key?(:href)
+        self.new(attrs[:href].split('/').last)
+
+      end
+
+      def vcloud_attributes
+        Vcloud::Fog::ServiceInterface.new.get_network(id)
+      end
+
+      def name
+        vcloud_attributes[:name]
+      end
+
+      def href
+        vcloud_attributes[:href]
+      end
+
+      def delete
+        Vcloud::Fog::ServiceInterface.new.delete_network(id)
+      end
+
+      private
+
+      def self.construct_network_options(config)
+        opts = {}
+        opts[:Description] = config[:description] if config.key?(:description)
+        opts[:IsShared] = config[:is_shared]
+
+        ip_scope = {}
+        ip_scope[:IsInherited] = config[:is_inherited] || false
+        ip_scope[:Gateway]     = config[:gateway] if config.key?(:gateway)
+        ip_scope[:Netmask]     = config[:netmask] if config.key?(:netmask)
+        ip_scope[:Dns1]        = config[:dns1] if config.key?(:dns1)
+        ip_scope[:Dns2]        = config[:dns2] if config.key?(:dns2)
+        ip_scope[:DnsSuffix]   = config[:dns_suffix] if config.key?(:dns_suffix)
+        ip_scope[:IsEnabled]   = config[:is_enabled] || true
+
+        if config.key?(:ip_ranges) && config[:ip_ranges].size > 0
+          ip_scope[:IpRanges] = []
+          config[:ip_ranges].each do |range|
+            ip_scope[:IpRanges] << {
+              :IpRange => {
+                :StartAddress => range[:start_address],
+                :EndAddress   => range[:end_address]
+              }
+            }
+          end
+        end
+
+        opts[:Configuration] = {
+          :FenceMode => config[:fence_mode],
+          :IpScopes => {
+            :IpScope => ip_scope
+          },
+        }
+
+        opts
+      end
+
+    end
+  end
+end