gogetit 0.1.16

data/lib/gogetit/cli.rb

@@ -0,0 +1,44 @@
+require 'thor'
+require 'gogetit'
+
+module Gogetit
+  class CLI < Thor
+    package_name 'Gogetit'
+
+    desc 'list', 'List containers and instances, running currently.'
+    def list
+      puts "Listing LXD containers on #{Gogetit.config[:lxd][:url]}.."
+      system("lxc list #{Gogetit.config[:lxd][:name]}:")
+      puts ''
+      puts "Listing KVM domains on #{Gogetit.config[:libvirt][:url]}.."
+      system("virsh -c #{Gogetit.config[:libvirt][:url]} list --all")
+    end
+
+    desc 'create (TYPE) NAME', 'Create either a container or KVM domain.'
+    def create(type=nil, name)
+      case type
+      when 'lxd', nil
+        Gogetit.lxd.create(name)
+      when 'libvirt'
+        Gogetit.libvirt.create(name)
+      else
+        puts 'Invalid argument entered'
+      end
+      Gogetit.config[:default][:user] ||= ENV['USER']
+      puts "ssh #{Gogetit.config[:default][:user]}@#{name}"
+    end
+
+    desc 'destroy NAME', 'Destroy either a container or KVM domain.'
+    def destroy(name)
+      type = Gogetit.get_provider_of(name)
+      if type
+        case type
+        when 'lxd', nil
+          Gogetit.lxd.destroy(name)
+        when 'libvirt'
+          Gogetit.libvirt.destroy(name)
+        end
+      end
+    end
+  end
+end

data/lib/gogetit/version.rb

@@ -0,0 +1,3 @@
+module Gogetit
+  VERSION = "0.1.16"
+end

data/lib/maas.rb

@@ -0,0 +1,119 @@
+require 'maas/client'
+
+module Gogetit
+  class GogetMAAS
+    attr_reader :config, :conn, :domain, :logger
+
+    def initialize(conf, logger)
+      @config = conf
+      @conn = Maas::Client::MaasClient.new(
+          config[:maas][:key],
+          config[:maas][:url]
+        )
+      @logger = logger
+    end
+
+    def get_domain
+      return @domain if @domain
+      logger.info("Calling <#{__method__.to_s}>")
+      @domain = conn.request(:get, ['domains'])[0]['name']
+    end
+
+    def machine_exists?(name)
+      logger.info("Calling <#{__method__.to_s}>")
+      conn.request(:get, ['machines']).each do |m|
+        return true if m['hostname'] == name
+      end
+      false
+    end
+
+    def dnsresource_exists?(name)
+      logger.info("Calling <#{__method__.to_s}>")
+      conn.request(:get, ['dnsresources']).each do |item|
+        return true if item['fqdn'] == name + '.' + get_domain
+      end
+      false
+    end
+
+    def domain_name_exists?(name)
+      return true if dnsresource_exists?(name) or machine_exists?(name)
+    end
+
+    def ipaddresses(op = nil, params = nil)
+      case op
+      when nil
+        conn.request(:get, ['ipaddresses'])
+      when 'reserve'
+        # sample = {
+        #   'subnet' => '10.1.2.0/24',
+        #   'ip' => '10.1.2.8',
+        #   'hostname' => 'hostname',
+        #   'mac' => 'blahblah'
+        # }
+        default_param = { 'op' => op }
+        conn.request(:post, ['ipaddresses'], default_param.merge!(params))
+      when 'release'
+        # Gogetit.maas.ipaddresses('release', {'ip' => '10.1.2.8'})
+        # sample = {
+        #   'ip' => '10.1.2.8',
+        #   'hostname' => 'hostname',
+        #   'mac' => 'blahblah'
+        # }
+        default_param = { 'op' => op }
+        conn.request(:post, ['ipaddresses'], default_param.merge!(params))
+      end
+    end
+
+    def delete_dns_record(name)
+      logger.info("Calling <#{__method__.to_s}>")
+      id = nil
+      conn.request(:get, ['dnsresources']).each do |item|
+        if item['fqdn'] == name + '.' + get_domain
+          id = item['id']
+        end
+      end
+
+      if ! id.nil?
+        conn.request(:delete, ['dnsresources', id.to_s])
+      else
+        logger.warn('No such record found.')
+      end
+    end
+
+    def refresh_pods
+      logger.info("Calling <#{__method__.to_s}>")
+      pod_id = conn.request(:get, ['pods'])
+      pod_id.each do |pod|
+        conn.request(:post, ['pods', pod['id']], { 'op' => 'refresh' } )
+      end
+    end
+
+    def get_system_id(name)
+      logger.info("Calling <#{__method__.to_s}>")
+      conn.request(:get, ['machines']).each do |m|
+        return m['system_id'] if m['hostname'] == name
+      end
+      nil
+    end
+
+    def wait_until_state(system_id, state)
+      logger.info("Calling <#{__method__.to_s}> for being #{state}")
+      until conn.request(:get, ['machines', system_id])['status_name'] == state
+        sleep 3
+      end
+    end
+
+    def get_machine_state(system_id)
+      logger.info("Calling <#{__method__.to_s}>")
+      conn.request(:get, ['machines']).each do |m|
+        return m['status_name'] if m['system_id'] == system_id
+      end
+      false
+    end
+
+    def change_hostname(system_id, hostname)
+      logger.info("Calling <#{__method__.to_s}>")
+      conn.request(:put, ['machines', system_id], { 'hostname' => hostname })
+    end
+  end
+end

data/lib/multilogger.rb

@@ -0,0 +1,56 @@
+require 'logger'
+
+module Gogetit
+  # It was just taken from below source. Thanks to clowder!
+  # https://gist.github.com/clowder/3639600
+  class MultiLogger
+    attr_reader :level
+
+    def initialize(args={})
+      @level = args[:level] || Logger::Severity::INFO
+      @loggers = []
+
+      Array(args[:loggers]).each { |logger| add_logger(logger) }
+    end
+
+    def add_logger(logger)
+      logger.level = level
+      @loggers << logger
+    end
+
+    def level=(level)
+      @level = level
+      @loggers.each { |logger| logger.level = level }
+    end
+
+    def datetime_format=(format)
+      @loggers.each { |logger| logger.datetime_format = format }
+    end
+
+    def formatter=(format)
+      @loggers.each { |logger| logger.formatter = format }
+    end
+
+    def progname=(name)
+      @loggers.each { |logger| logger.progname = name }
+    end
+
+    def close
+      @loggers.map(&:close)
+    end
+
+    def add(level, *args)
+      @loggers.each { |logger| logger.add(level, args) }
+    end
+
+    Logger::Severity.constants.each do |level|
+      define_method(level.downcase) do |*args|
+        @loggers.each { |logger| logger.send(level.downcase, args) }
+      end
+
+      define_method("#{ level.downcase }?".to_sym) do
+        @level <= Logger::Severity.const_get(level)
+      end
+    end
+  end
+end

data/lib/providers/libvirt.rb

@@ -0,0 +1,260 @@
+require 'libvirt'
+require 'securerandom'
+require 'oga'
+require 'rexml/document'
+require 'util'
+
+module Gogetit
+  class GogetLibvirt
+    include Gogetit::Util
+
+    attr_reader :config, :conn, :maas, :logger
+
+    def initialize(conf, maas, logger)
+      @config = conf
+      @conn = Libvirt::open(config[:libvirt][:url])
+      @maas = maas
+      @logger = logger
+    end
+
+    def get_domain_list
+      logger.info("Calling <#{__method__.to_s}>")
+      domains = []
+      conn.list_all_domains.each do |d|
+        domains << d.name
+      end
+      domains
+    end
+
+    def domain_exists?(name)
+      logger.info("Calling <#{__method__.to_s}>")
+      get_domain_list.each do |d|
+        return true if d == name
+      end
+      false
+    end
+
+    def get_mac_addr(domain_name)
+      logger.info("Calling <#{__method__.to_s}>")
+       Oga.parse_xml(conn.lookup_domain_by_name(domain_name).xml_desc)
+        .at_xpath('domain/devices/interface[1]/mac')
+        .attribute('address')
+        .value
+    end
+
+    # subject.create(name: 'test01')
+    def create(name, conf_file = nil)
+      logger.info("Calling <#{__method__.to_s}>")
+      if maas.domain_name_exists?(name) or domain_exists?(name)
+        puts "Domain #{name} already exists! Please check both on MAAS and libvirt."
+        return false
+      end
+
+      conf_file ||= config[:default_provider_conf_file]
+      domain = symbolize_keys(YAML.load_file(conf_file))
+      domain[:name] = name
+      domain[:uuid] = SecureRandom.uuid
+
+      dom = conn.define_domain_xml(define_domain(domain))
+      maas.refresh_pods
+
+      system_id = maas.get_system_id(domain[:name])
+      maas.wait_until_state(system_id, 'Ready')
+      logger.info("Calling to deploy...")
+      maas.conn.request(:post, ['machines', system_id], {'op' => 'deploy'})
+      maas.wait_until_state(system_id, 'Deployed')
+      logger.info("#{domain[:name]} has been created.")
+      true
+    end
+
+    def destroy(name)
+      logger.info("Calling <#{__method__.to_s}>")
+      system_id = maas.get_system_id(name)
+      if maas.machine_exists?(name)
+        if maas.get_machine_state(system_id) == 'Deployed'
+          logger.info("Calling to release...")
+          maas.conn.request(:post, ['machines', system_id], {'op' => 'release'})
+          maas.wait_until_state(system_id, 'Ready')
+        end
+        maas.conn.request(:delete, ['machines', system_id])
+      end
+
+      pools = []
+      conn.list_storage_pools.each do |name|
+        pools << self.conn.lookup_storage_pool_by_name(name)
+      end
+
+      dom = conn.lookup_domain_by_name(name)
+      dom.destroy if dom.active?
+      Oga.parse_xml(dom.xml_desc).xpath('domain/devices/disk/source').each do |d|
+        pool_path = d.attribute('file').value.split('/')[0..2].join('/')
+        pools.each do |p|
+          if Oga.parse_xml(p.xml_desc).at_xpath('pool/target/path').inner_text == pool_path
+            logger.info("Deleting volume in #{p.name} pool.")
+            p.lookup_volume_by_name(d.attribute('file').value.split('/')[3]).delete
+          end
+        end
+      end
+      dom.undefine
+
+      maas.refresh_pods
+      logger.info("#{name} has been destroyed.")
+      true
+    end
+
+    def define_domain(domain)
+      logger.info("Calling <#{__method__.to_s}>")
+      template = File.read(config[:lib_dir] + '/template/domain.xml')
+      doc = Oga.parse_xml(template)
+
+      name = domain[:name]
+      doc.at_xpath('domain/name').inner_text = name
+      uuid = domain[:uuid]
+      doc.at_xpath('domain/uuid').inner_text = uuid
+      vcpu = domain[:vcpu].to_s
+      doc.at_xpath('domain/vcpu').inner_text = vcpu
+      memory = domain[:memory].to_s
+      doc.at_xpath('domain/memory').inner_text = memory
+      doc.at_xpath('domain/currentMemory').inner_text = memory
+
+      doc = define_volumes(doc, domain)
+      doc = add_nic(doc, domain[:nic])
+
+      #print_xml(doc)
+      #volumes.each do |v|
+      #  print_xml(v)
+      #end
+
+      return Oga::XML::Generator.new(doc).to_xml
+    end
+
+    def print_xml(doc)
+      logger.info("Calling <#{__method__.to_s}>")
+      output = REXML::Document.new(Oga::XML::Generator.new(doc).to_xml)
+      formatter = REXML::Formatters::Pretty.new
+      formatter.compact = true
+      formatter.write(output, $stdout)
+    end
+
+    def get_pool_path(pool)
+      logger.info("Calling <#{__method__.to_s}>")
+      path = nil
+      conn.list_all_storage_pools.each do |p|
+        if p.name == pool
+          pool_doc = Oga.parse_xml(p.xml_desc)
+          path = pool_doc.at_xpath('pool/target/path').inner_text
+        end
+      end
+
+      if path
+        return path
+      else
+        raise 'No such pool found.'
+      end
+    end
+
+    def define_volumes(document, domain)
+      logger.info("Calling <#{__method__.to_s}>")
+      disk_template = File.read(config[:lib_dir] + '/template/disk.xml')
+      disk_doc = Oga.parse_xml(disk_template)
+      volume_template = File.read(config[:lib_dir] + '/template/volume.xml')
+      volume_doc = Oga.parse_xml(volume_template)
+
+      defined_volumes = []
+
+      # For root volume
+      pool_path = get_pool_path(domain[:disk][:root][:pool])
+      volume_name = "#{domain[:name]}_root_sda.qcow2"
+      volume_file = pool_path + "/" + volume_name
+      disk_doc.at_xpath('disk/source').attribute('file').value = volume_file
+      document.at_xpath('domain/devices').children << disk_doc.at_xpath('disk')
+
+      volume_doc.at_xpath('volume/name').inner_text = volume_name
+      volume_doc.at_xpath('volume/target/path').inner_text = volume_file
+      volume_doc.at_xpath('volume/capacity').inner_text = domain[:disk][:root][:capacity].to_s
+
+      create_volume(domain[:disk][:root][:pool], Oga::XML::Generator.new(volume_doc).to_xml)
+      defined_volumes << volume_doc
+
+      # For data(secondary) volumes
+      if domain[:disk][:data] != [] and domain[:disk][:data] != nil
+        disk_index = 98
+        domain[:disk][:data].each do |v|
+          pool_path = get_pool_path(v[:pool])
+          volume_index = "sd" + disk_index.chr
+          volume_name = "#{domain[:name]}_data_#{volume_index}.qcow2"
+          volume_file = pool_path + "/" + volume_name
+          disk_doc = Oga.parse_xml(disk_template)
+          disk_doc.at_xpath('disk/source').attribute('file').value = volume_file
+          disk_doc.at_xpath('disk/target').attribute('dev').value = volume_index
+          document.at_xpath('domain/devices').children << disk_doc.at_xpath('disk')
+
+          volume_doc = Oga.parse_xml(volume_template)
+          volume_doc.at_xpath('volume/name').inner_text = volume_name
+          volume_doc.at_xpath('volume/target/path').inner_text = volume_file
+          volume_doc.at_xpath('volume/capacity').inner_text = v[:capacity].to_s
+          create_volume(v[:pool], Oga::XML::Generator.new(volume_doc).to_xml)
+          defined_volumes << volume_doc
+          disk_index += 1
+        end
+      end
+
+      return document
+    end
+
+    def create_volume(pool_name, volume_doc)
+      logger.info("Calling <#{__method__.to_s}> to create volume in #{pool_name} pool.")
+      pool = conn.lookup_storage_pool_by_name(pool_name)
+      pool.create_volume_xml(volume_doc)
+      pool.refresh
+    end
+
+    def add_nic(document, nic_conf)
+      logger.info("Calling <#{__method__.to_s}>")
+      template = File.read(config[:lib_dir] + "/template/nic.xml")
+      doc = Oga.parse_xml(template)
+
+      nic_conf.each do |nic|
+        doc = Oga.parse_xml(template)
+        doc.at_xpath('interface/source').attribute('network').value = nic[:network]
+        doc.at_xpath('interface/source').attribute('portgroup').value = nic[:portgroup]
+        document.at_xpath('domain/devices').children << doc.at_xpath('interface')
+      end
+
+      document
+    end
+
+    #def generate_xml
+    #  domain = Oga::XML::Element.new(name: 'domain')
+    #  domain.add_attribute(Oga::XML::Attribute.new(name: "type", value: "kvm"))
+    #  name = Oga::XML::Element.new(name: 'name')
+    #  name.inner_text = 'ceph'
+    #  domain.children << name
+    #  doc = REXML::Document.new(Oga::XML::Generator.new(domain).to_xml)
+    #  formatter = REXML::Formatters::Pretty.new
+    #  formatter.compact = true
+    #  formatter.write(doc, $stdout)
+
+    #  disk = create_element(name: 'domain')
+    #  disk.add_attribute(Oga::XML::Attribute.new(name: "type", value: "file"))
+    #  disk.add_attribute(Oga::XML::Attribute.new(name: "device", value: "disk"))
+    #  driver = create_element(name: 'domain')
+    #  driver.add_attribute(Oga::XML::Attribute.new(name: "name", value: "qemu"))
+    #  driver.add_attribute(Oga::XML::Attribute.new(name: "type", value: "qcow2"))
+    #  source = create_element(name: 'source')
+    #  source.add_attribute(Oga::XML::Attribute.new(name: "file", value: file))
+    #  target = create_element(name: 'target')
+    #  target.add_attribute(Oga::XML::Attribute.new(name: "dev", value: seq_name))
+    #  target.add_attribute(Oga::XML::Attribute.new(name: "bus", value: "scsi"))
+
+    #end
+
+    #def create_element(name)
+    #  Oga::XML::Element.new(name: name)
+    #end
+
+    #def add_attribute(element, hash)
+    #  element.add_attribute(Oga::XML::Attribute.new(hash))
+    #end
+  end
+end