pec 0.4.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c854b8e393a921d53b14b6faa4704c69179e89f
-  data.tar.gz: b5e10b9145475986f2f59b23fb762bcac456bd1b
+  metadata.gz: 8a7355209a3c35e40ac68d514cae1e0ed75e8102
+  data.tar.gz: ea45ced7c65397076d2c7496eb5efe44ffa6d41a
 SHA512:
-  metadata.gz: fc62df875382a1a9e46f84592212f69ec4c015132aa2804f8b698084b3af401218c6c005df8cf41dc7442bde7cd85910f3c1221dcc394c06f4c2063839fdc009
-  data.tar.gz: aa06178e8af7c13cb6019ee4db98624f873be9ab1e2368730522ce5942e548348d788162f71d2a1a34be1af2270f2c9b3c2f822d9576df782e01011aeeff040c
+  metadata.gz: 3f40e9678fbd05ffeac16fac0ca9eb1832185a38526a188149a473dee6d8e397d1250b1c081a30b687262fb02e7ebab83b02c53dcca3d9b03f7cb4f15daffdb8
+  data.tar.gz: 57feae3668f00d475f1b1be8871294caa4fb7ac72ace25a78a9af76e57220cf1dd70dcf58e4aa7e5b5392e20db6c782cf49fd11459c664c44046697d56accc1d

data/.gitignore

@@ -11,3 +11,4 @@
 /*.yaml
 *.sample
 /user_datas
+.ruby-version

data/README.md

@@ -37,6 +37,7 @@ _default_: &def
   tenant: your_tenant
   image: centos-7.1_chef-12.3_puppet-3.7
   flavor: m1.small
+  availability_zone: nova
 
 pyama-test001:
   <<: *def
@@ -74,8 +75,10 @@ pyama-test002:
 | flavor         | フレーバー名                                   | ○    | m1.small                        |
 | networks       | ネットワーク定義                               | -    | []                              |
 | security_group | セキュリティグループ名                         | -    | [default,ssh]                   |
-| templates      | `user_data`のテンプレート.`./user_data`に配置 | -    | [base.yaml,webserver.yaml]      |
+| templates      | `user_data`のテンプレート `./user_data` に配置 | -    | [base.yaml,webserver.yaml]      |
 | user_data      | cloud-init記法に準拠                           | -    | -                               |
+| availability_zone | アベイラビリティゾーン                     |  -    | nova                     |
+
 * 先頭が_で開始されるインスタンス名はyaml merge記法用途と認識し、スキップします
 
 ##### Networks

data/lib/pec.rb

@@ -2,42 +2,45 @@ require 'fog'
 require 'ip'
 require 'colorator'
 require "pec/version"
-require "pec/query"
-require "pec/errors"
-require "pec/init"
-require "pec/resource"
-require "pec/resource/openstack"
-require "pec/resource/mock"
-require "pec/director"
-require "pec/director/helper"
-require "pec/director/make_director"
-require "pec/director/destroy_director"
-require "pec/director/vm_status_director"
+require "pec/logger"
 require "pec/configure"
-require "pec/configure/sample"
-require "pec/configure/host"
-require "pec/configure/ethernet"
-require "pec/configure/user_data"
-require "pec/compute/server"
-require "pec/compute/flavor"
-require "pec/compute/image"
-require "pec/compute/tenant"
-require "pec/network/security_group"
-require "pec/network/port"
-require "pec/network/port_state"
-require "pec/network/subnet"
+require "pec/director"
+require "pec/builder/server"
+require "pec/builder/port"
+require "pec/builder/user_data"
 require "pec/cli"
 
 module Pec
-end
+  def self.compute
+    @_compute ||= Fog::Compute.new({
+      provider: 'openstack'
+    })
+    @_compute
+  end
+  
+  def self.neutron
+    @_neutron ||= Fog::Network.new({
+      provider: 'openstack'
+    })
+    @_neutron
+  end
+  
+  def self.identity
+    @_identity ||= Fog::Identity.new({
+      provider: 'openstack'
+    })
+    @_identity
+  end
 
-class ::Hash
-    def deep_merge(second)
-        merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
-        self.merge(second.to_h, &merger)
-    end
-    def deep_merge!(second)
-        merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
-        self.merge!(second.to_h, &merger)
+  def self.load_config(file_name=nil)
+    file_name ||= 'Pec.yaml'
+    @_configure = []
+    YAML.load_file(file_name).to_hash.reject {|c| c[0].to_s.match(/^_/)}.each do |host|
+      @_configure << Pec::Configure.new(host)
     end
+  end
+
+  def self.configure
+    @_configure
+  end
 end

data/lib/pec/builder/port.rb

@@ -0,0 +1,120 @@
+module Pec
+  module Builder
+    class Port
+      attr_reader :user_data
+      def build(host)
+        ports = []
+        @user_data = []
+
+        host.networks.each do |network|
+          validate(network)
+          Pec::Logger.notice "port create start : #{network[0]}"
+          port = create_port(host, network)
+          Pec::Logger.notice "assgin ip : #{port.fixed_ips.first["ip_address"]}"
+          ports << port
+          @user_data << gen_user_data(network, port)
+        end
+        {
+          nics: ports.map {|port| { port_id: port.id }}
+        }
+      end
+
+      def validate(network)
+        %w(
+          bootproto
+          ip_address
+        ).each do |k|
+          raise "network key #{k} is require" unless network[1][k]
+        end
+      end
+
+      def create_port(host, network)
+        ip = IP.new(network[1]['ip_address'])
+        subnet = Pec.neutron.subnets.find {|s|s.cidr == ip.network.to_s}
+        attribute = gen_port_attribute(host, network, subnet, ip)
+        Pec.neutron.ports.create(attribute)
+      end
+     
+      def gen_port_attribute(host, network, subnet, ip)
+        attribute = {
+          name: network[0],
+          network_id: subnet.network_id
+        }
+
+        attribute.merge!(
+          fixed_ip(subnet, ip) 
+        ) if ip.to_s != subnet.cidr
+
+        attribute.merge!(
+          security_group(host)
+        ) if host.security_group
+
+        attribute.merge!(
+          allowed_address_pairs(network)
+        ) if network[1]['allowed_address_pairs']
+        attribute
+      end
+     
+      def gen_user_data(network, port)
+        path = network[1]['path'] || "/etc/sysconfig/network-scripts/ifcfg-#{port.name}"
+        {
+          'content' => ifcfg_config(network, port),
+          'owner' => "root:root",
+          'path' => path,
+          'permissions' => "0644"
+        }
+      end
+      
+      def ifcfg_config(network, port)
+        base = {
+          "name"      => port.name,
+          "device"    => port.name,
+          "type"      => 'Ethernet',
+          "onboot"    => 'yes',
+          "hwaddr"    => port.mac_address
+        }
+        
+        base.merge!(
+          {
+            "netmask" => IP.new(network[1]['ip_address']).netmask.to_s,
+            "ipaddr"  => port.fixed_ips.first['ip_address'].split("/").first
+          }
+        ) if network[1]['bootproto'] == "static"
+
+        # delete options
+        %w(allowed_address_pairs ip_address).each {|name| network[1].delete(name)}
+        
+        base.merge!(
+          network[1]
+        )
+
+        base.map {|k,v| "#{k.upcase}=#{v}"}.join("\n")
+      end
+
+      #
+      # after port options
+      #
+      def fixed_ip(subnet, ip)
+        { 
+          fixed_ips: [
+            { subnet_id: subnet.id, ip_address: ip.to_addr}
+          ]
+        }
+      end
+
+      def security_group(host)
+        ids =  host.security_group.map do |name|
+          Pec.neutron.security_groups.find {|sg| sg.name == name}.id
+        end
+        { security_groups: ids }
+      end
+
+      def allowed_address_pairs(network)
+        pairs = network[1]['allowed_address_pairs'].map do |pair|
+          { ip_address: pair['ip_address'] }
+        end
+        { allowed_address_pairs: pairs }
+      end
+    end
+  end
+end

data/lib/pec/builder/server.rb

@@ -0,0 +1,28 @@
+module Pec
+  module Builder
+    class Server
+      def build(host)
+        Pec::Logger.notice "flavor is #{host.flavor}"
+        Pec::Logger.notice "image is #{host.image}"
+        hash = {
+          name: host.name,
+          flavor_ref: fetch_flavor(host).id,
+          image_ref:  fetch_image(host).id
+        }
+        hash[:availability_zone] = host.availability_zone if host.availability_zone
+        hash
+      end
+      
+      def self.resource(name)
+        define_method("fetch_#{name}", -> (host) {
+          r = Pec.compute.send("#{name}s").find {|val|val.name == host.send(name)}
+          raise "not fond #{name} #{host.send(name)}" unless r
+          r
+        })
+      end
+
+      resource 'flavor'
+      resource 'image'
+    end
+  end
+end

data/lib/pec/builder/user_data.rb

@@ -0,0 +1,39 @@
+module Pec
+  module Builder
+    class UserData
+      def build(host, port_user_data) 
+          user_data = default(host)
+          user_data["write_files"] = port_user_data if port_user_data
+          if template = load_template(host)
+            user_data.deep_merge!(template) 
+          end 
+          { user_data: "#cloud-config\n" + user_data.to_yaml }
+      end
+
+      def load_template(host)
+        host.templates.inject({}) do |merge_template, template|
+          template.to_s.concat('.yaml') unless template.to_s.match(/.*\.yaml/)
+          raise "#{template} not fond!" unless FileTest.exist?("user_data/#{template}")
+          merge_template.deep_merge!(YAML.load_file("user_data/#{template}").to_hash)
+        end if host.templates
+      end 
+
+      def default(host)
+        _def = host.user_data || {}
+        _def['fqdn'] = host.name if host.user_data && !host.user_data['fqdn'] 
+        _def
+      end
+    end
+  end
+end
+
+class ::Hash
+    def deep_merge(second)
+        merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
+        self.merge(second.to_h, &merger)
+    end
+    def deep_merge!(second)
+        merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
+        self.merge!(second.to_h, &merger)
+    end
+end

data/lib/pec/cli.rb

@@ -12,19 +12,19 @@ module Pec
 
     desc 'up', 'create vm by Pec.yaml'
     def up(host_name = nil)
-      Pec::Director.execute("make", host_name)
+      Pec::Director.make(host_name)
     end
 
     option :force , type: :boolean, aliases: "-f"
     desc "destroy", "delete vm"
     def destroy(host_name = nil)
-      Pec::Director.execute("destroy", host_name, options)
+      Pec::Director.destroy(host_name, options)
     end
 
     desc "status", "vm status"
     def status(host_name = nil)
       say("Current machine stasus:", :yellow)
-      Pec::Director.execute("vm_status", host_name)
+      Pec::Director.status(host_name)
     end
   end
 end

data/lib/pec/configure.rb

@@ -1,36 +1,27 @@
-require 'yaml'
 module Pec
   class Configure
-    include Enumerable
-
-    def initialize(file_name)
-      @configure = []
-
-      if file_name.is_a?(Hash)
-        hash = file_name
-      else
-        hash = YAML.load_file(file_name).to_hash
-      end
-     
-      hash.reject {|c| c[0].to_s.match(/^_/)}.each do |config|
-
-        config[1]['user_data'] ||= {}
-        config[1]['user_data']['fqdn'] ||= config[0].to_s
+    def initialize(config)
+      validate(config)
+      @_config = config
+    end
 
-        host = Pec::Configure::Host.new(config)
-        @configure << host if host
-      end
-      rescue Psych::SyntaxError,NoMethodError => e
-        raise(Pec::Errors::Configure, e)
+    def name
+      @_config[0]
     end
 
-    def filter_by_host(host_name)
-      @configure.select {|h| host_name.nil? || host_name == h.name}
+    def method_missing(method, *args)
+      nil unless @_config[1][method.to_s]
+      @_config[1][method.to_s]
     end
 
-    def each
-      @configure.each do |config|
-        yield config
+    def validate(host)
+      %w(
+        tenant 
+        image
+        flavor
+        networks
+      ).each do |k|
+        raise "host key #{k} is require" unless host[1][k]
       end
     end
   end

data/lib/pec/director.rb

@@ -1,57 +1,116 @@
 module Pec
-class Director
-    class << self
-
-      def execute(action, host_name, options=nil)
-        config = Pec::Configure.new("Pec.yaml")
-        director = assign_director(action, options)
-        config.filter_by_host(host_name).each do |host|
-          begin
-            director.execute!(host) if director.do_it?(host)
-          rescue Pec::Errors::Error => e
-            director.err_message(e, host)
-          rescue Excon::Errors::SocketError => e
-            err_message(e)
-          rescue Excon::Errors::Error => e
-            excon_err_message(e)
-          end
-        end if config
-
-        rescue Pec::Errors::Configure => e
-          config_load_err_message(e)
-        rescue Pec::Errors::Error => e
-          err_message(e)
-        rescue Errno::ENOENT => e
-          err_message(e)
+  class Director
+    def self.make(host_name)
+      Pec.load_config
+      Pec.configure.each do |host|
+        next if host_name && host.name != host_name
+        Pec::Logger.info "make start #{host.name}"
+        
+        Pec.compute.set_tenant(host.tenant)
+        Pec.neutron.set_tenant_patch(host.tenant)
+       
+        port_builder = Pec::Builder::Port.new
+        server_builder = Pec::Builder::Server.new
+        user_data_builder = Pec::Builder::UserData.new
+
+        attribute = {}
+        attribute.merge!(server_builder.build(host))
+        attribute.merge!(port_builder.build(host))
+
+        if user_data = user_data_builder.build(host, port_builder.user_data)
+          attribute.merge!(user_data)
+        end
+        
+        Pec::Logger.info "create success! #{host.name}" if Pec.compute.servers.create(attribute)
       end
 
-      def assign_director(action, options)
-        case
-        when action == "make"
-          Pec::Director::MakeDirector.new
-        when action == "destroy"
-          Pec::Director::DestroyDirector.new(options)
-        when action == "vm_status"
-          Pec::Director::VmStatusDirector.new
-        else
-          raise
+      rescue Excon::Errors::Error => e
+        excon_err_message(e)
+      rescue => e
+        Pec::Logger.critical(e)
+    end
+
+    def self.destroy(host_name, options)
+      Pec.load_config
+      Pec.configure.each do |host|
+        next if host_name && host.name != host_name
+        Pec.compute.set_tenant(host.tenant)
+        
+        server = Pec.compute.servers.find {|s|s.name == host.name}
+        unless server
+          Pec::Logger.notice "not be created #{host.name}"
+          next
+        end
+        
+        if options[:force] || Thor.new.yes?("#{host.name}: Are you sure you want to destroy the '#{host.name}' VM? [y/N]")
+          Pec::Logger.info "#{host.name} is deleted!" if Pec.compute.servers.destroy(server.id)
         end
       end
+      rescue Excon::Errors::Error => e
+        excon_err_message(e)
+      rescue => e
+        Pec::Logger.critical(e)
+    end
+
+    def self.status(host_name)
+      Pec.load_config
+      Pec.configure.each do |host|
+        next if host_name && host.name != host_name
+        server = Pec.compute.servers.find {|s|s.name == host.name}
+        if server
+          puts sprintf(" %-35s %-10s %-10s %-10s %-10s %-35s %-48s",
+            host.name,
+            server.state,
+            Pec.identity.tenants.find_by_id(server.tenant_id),
+            Pec.compute.flavors.get(server.flavor['id']).name,
+            server.availability_zone,
+            server.os_ext_srv_attr_host,
+            server.addresses.map do |net, ethers|                                                                                                    
+              ethers.map do |ether|                                                                                                           
+                ether["addr"]                                                                                                                 
+              end                                                                                                                             
+            end.flatten.join(",")
+          )
 
-      def err_message(e)
-        puts e.to_s.magenta
+        else
+          puts sprintf(" %-35s %-10s",
+            host.name,
+            "uncreated"
+          )
+        end
       end
 
-      def config_load_err_message(e)
-        puts e
-        puts "can't load configfile".magenta
+      rescue Excon::Errors::Error => e
+        excon_err_message(e)
+      rescue => e
+        Pec::Logger.critical(e)
+    end
+
+    def self.excon_err_message(e)
+      if e.response
+        JSON.parse(e.response[:body]).each { |e,m| Pec::Logger.critical("#{e}:#{m["message"]}") }
+      else
+        Pec::Logger.critical(e)
       end
+    end
+  end
+end
 
-      def excon_err_message(e)
-        if e.response
-          JSON.parse(e.response[:body]).each { |e,m| puts "#{e}:#{m["message"]}".magenta }
-        else
-          puts e
+module Fog
+  module Network
+    class OpenStack
+      class Real
+        def set_tenant_patch(tenant)
+          @openstack_must_reauthenticate = true
+          @openstack_tenant = tenant.to_s
+          authenticate
+          @path.sub!(/\/$/, '')
+          unless @path.match(SUPPORTED_VERSIONS)
+            @path = "/" + Fog::OpenStack.get_supported_version(SUPPORTED_VERSIONS,
+                                                               @openstack_management_uri,
+                                                               @auth_token,
+                                                               @connection_options)
+          end
         end
       end
     end