gapinc-rbvmomi 1.6.0

data/.gitignore

@@ -0,0 +1,11 @@
+*.swp
+*.swo
+pkg/
+*.gemspec
+vmodl
+doc
+.yardoc
+*.rbc
+coverage
+*.gem
+Gemfile.lock

data/.yardopts

@@ -0,0 +1,6 @@
+--title "RbVmomi - a Ruby interface to the vSphere API"
+--no-private
+--readme README.rdoc
+lib/rbvmomi/vim.rb
+lib/rbvmomi/vim/*.rb
+lib/rbvmomi/trollop.rb

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+gemspec
+

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 VMware, Inc.  All Rights Reserved.
+
+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.rdoc

@@ -0,0 +1,78 @@
+= RbVmomi
+
+== Introduction
+
+RbVmomi is a Ruby interface to the vSphere API. Like the Perl and Java SDKs,
+you can use it to manage ESX and VirtualCenter servers. The current release
+supports the vSphere 5.0 API. RbVmomi specific documentation is
+online[http://rdoc.info/github/rlane/rbvmomi/master/frames] and is meant to
+be used alongside the official documentation[http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/index.html].
+
+== Installation
+
+    gem install rbvmomi
+
+== Usage
+
+A simple example of turning on a VM:
+
+    require 'rbvmomi'
+    vim = RbVmomi::VIM.connect host: 'foo', user: 'bar', password: 'baz'
+    dc = vim.serviceInstance.find_datacenter("mydatacenter") or fail "datacenter not found"
+    vm = dc.find_vm("myvm") or fail "VM not found"
+    vm.PowerOnVM_Task.wait_for_completion
+
+This code uses several RbVmomi extensions to the vSphere API for concision. The
+expanded snippet below uses only standard API calls and should be familiar to
+users of the Java SDK:
+
+    require 'rbvmomi'
+    vim = RbVmomi::VIM.connect host: 'foo', user: 'bar', password: 'baz'
+    rootFolder = vim.serviceInstance.content.rootFolder
+    dc = rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).find { |x| x.name == "mydatacenter" } or fail "datacenter not found"
+    vm = dc.vmFolder.childEntity.grep(RbVmomi::VIM::VirtualMachine).find { |x| x.name == "myvm" } or fail "VM not found"
+    task = vm.PowerOnVM_Task
+    filter = vim.propertyCollector.CreateFilter(
+      spec: {
+        propSet: [{ type: 'Task', all: false, pathSet: ['info.state']}],
+        objectSet: [{ obj: task }]
+      },
+      partialUpdates: false
+    )
+    ver = ''
+    while true
+      result = vim.propertyCollector.WaitForUpdates(version: ver)
+      ver = result.version
+      break if ['success', 'error'].member? task.info.state
+    end
+    filter.DestroyPropertyFilter
+    raise task.info.error if task.info.state == 'error'
+
+As you can see, the extensions RbVmomi adds can dramatically decrease the code
+needed to perform simple tasks while still letting you use the full power of
+the API when necessary. RbVmomi extensions are often more efficient than a
+naive implementation; for example, the find_vm method on VIM::Datacenter used
+in the first example uses the SearchIndex for fast lookups.
+
+A few important points:
+
+* All class, method, parameter, and property names match the official documentation[http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/index.html].
+* Properties are exposed as accessor methods.
+* Data object types can usually be inferred from context, so you may use a hash instead.
+* Enumeration values are simply strings.
+* Example code is included in the examples/ directory.
+* A set of helper methods for Trollop is included to speed up development of
+  command line apps. See the included examples for usage.
+* If you don't have trusted SSL certificates installed on the host you're
+  connecting to, you'll get an +OpenSSL::SSL::SSLError+ "certificate verify failed".
+  You can work around this by using the +:insecure+ option to +RbVmomi::VIM.connect+.
+* This is a side project of a VMware employee and is entirely unsupported by VMware.
+
+Built-in extensions are under +lib/rbvmomi/vim/+. You are encouraged to
+reopen VIM classes in your applications and add extensions of your own. If you
+write something generally useful please send it to me and I'll add it in.
+
+== Development
+
+Fork the project on Github and send me a merge request, or send a patch to
+rlane@vmware.com. RbVmomi developers hang out in #rbvmomi on Freenode.

data/Rakefile

@@ -0,0 +1,47 @@
+# require 'rake/testtask'
+# require 'rake/rdoctask'
+require 'rdoc/task'
+require 'yard'
+
+# begin
+#   require 'jeweler'
+#   Jeweler::Tasks.new do |gem|
+#     gem.name = "rbvmomi"
+#     gem.summary = "Ruby interface to the VMware vSphere API"
+#     #gem.description = ""
+#     gem.email = "rlane@vmware.com"
+#     gem.homepage = "https://github.com/vmware/rbvmomi"
+#     gem.authors = ["Rich Lane", "Christian Dickmann"]
+#     gem.add_dependency 'nokogiri', '>= 1.4.1'
+#     gem.add_dependency 'builder'
+#     gem.add_dependency 'trollop'
+#     gem.required_ruby_version = '>= 1.8.7'
+#     gem.files.include 'vmodl.db'
+#     gem.files.include '.yardopts'
+#   end
+# rescue LoadError
+#   puts "Jeweler not available. Install it with: gem install jeweler"
+# end
+# 
+# Rake::TestTask.new do |t|
+#   t.libs << "test"
+#   t.test_files = FileList['test/test_*.rb']
+#   t.verbose = true
+# end
+
+YARD::Rake::YardocTask.new
+
+# begin
+#   require 'rcov/rcovtask'
+#   desc 'Measures test coverage using rcov'
+#   Rcov::RcovTask.new do |rcov|
+#     rcov.pattern    = 'test/test_*.rb'
+#     rcov.output_dir = 'coverage'
+#     rcov.verbose    = true
+#     rcov.libs << "test"
+#     rcov.rcov_opts << '--exclude "gems/*"'
+#   end
+# rescue LoadError
+#   puts "Rcov not available. Install it with: gem install rcov"
+# end
+

data/VERSION

@@ -0,0 +1 @@
+1.6.0

data/bin/rbvmomish

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+# TODO keepalive
+# TODO rc file
+# TODO proxy support?
+require 'trollop'
+require 'readline'
+require 'rbvmomi'
+require 'rbvmomi/trollop'
+
+VIM = RbVmomi::VIM
+
+opts = Trollop.options do
+  banner <<-EOS
+vSphere API console.
+
+Usage:
+       rbvmomish [options]
+
+Predefined methods:
+conn: Returns the VIM connection
+si: Returns the ServiceInstance
+help: Displays this text.
+
+Special syntax:
+Adding a '#' suffix to an expression displays information about the type of the
+result, including its properties and methods, instead of the value.
+
+VIM connection options:
+  EOS
+
+  rbvmomi_connection_opts
+
+  text <<-EOS
+
+Other options:
+  EOS
+
+  $trollop = self
+end
+
+begin
+  $vim = VIM.connect opts
+rescue Errno::EHOSTUNREACH
+  abort $!.message
+end
+
+typenames = VIM.loader.typenames
+Readline.completion_append_character = " "
+Readline.completion_proc = lambda do |word|
+  return unless word
+  prefix_regex = /^#{Regexp.escape(word)}/
+  candidates = typenames.sort
+  candidates.find_all { |e| e.match(prefix_regex) }
+end
+
+history_fn = "#{ENV['HOME']}/.rbvmomish-history"
+IO.foreach(history_fn) { |l| Readline::HISTORY << l.chomp } rescue nil
+history = File.open(history_fn, 'a')
+
+def type name
+  klass = VIM.type(name) rescue err("invalid type #{name.inspect}")
+  q = lambda { |x| x =~ /^xsd:/ ? $' : x }
+  if klass < VIM::DataObject
+    puts "Data Object #{klass}"
+    klass.full_props_desc.each do |desc|
+      puts " #{desc['name']}: #{q[desc['wsdl_type']]}#{desc['is-array'] ? '[]' : ''}"
+    end
+  elsif klass < VIM::ManagedObject
+    puts "Managed Object #{klass}"
+    puts
+    puts "Properties:"
+    klass.full_props_desc.each do |desc|
+      puts " #{desc['name']}: #{q[desc['wsdl_type']]}#{desc['is-array'] ? '[]' : ''}"
+    end
+    puts
+    puts "Methods:"
+    klass.full_methods_desc.sort_by(&:first).each do |name,desc|
+      params = desc['params']
+      puts " #{name}(#{params.map { |x| "#{x['name']} : #{q[x['wsdl_type'] || 'void']}#{x['is-array'] ? '[]' : ''}" } * ', '}) : #{q[desc['result']['wsdl_type'] || 'void']}"
+    end
+  else
+    err("cannot introspect type #{klass}")
+  end
+  nil
+end
+
+class UserError < RuntimeError; end
+def err msg
+  raise UserError.new(msg)
+end
+
+def cookie str
+  $vim.cookie = str
+end
+
+def conn
+  $vim
+end
+
+def si
+  $vim.serviceInstance
+end
+
+def help
+  $trollop.educate
+  :no_result
+end
+
+$binding = $vim.instance_eval { binding }
+
+loop do
+begin
+  input = Readline.readline("#{opts[:host]}> ", false) or break
+  input = input.strip
+  next if input.empty?
+
+  (history.puts input; Readline::HISTORY << input) unless input == Readline::HISTORY.to_a[-1]
+
+  result = eval(input, $binding)
+  if input =~ /\#$/
+    type result.class.wsdl_name
+  else
+    pp result unless result == :no_result
+  end
+rescue SystemExit, IOError
+  raise
+rescue RuntimeError, RbVmomi::Fault
+  puts "#{$!.class}: #{$!.message}"
+  puts $!.backtrace * "\n"
+rescue UserError
+  puts $!.message
+rescue Interrupt
+  puts
+rescue Exception
+  puts "#{$!.class}: #{$!.message}"
+  puts $!.backtrace * "\n"
+end
+end

data/devel/analyze-vim-declarations.rb

@@ -0,0 +1,200 @@
+#!/usr/bin/env ruby
+require 'nokogiri'
+
+# :usage => analyze-vim-declarations.rb vim-declarations.xml foo-declarations.xml vmodl.db
+
+XML_FNS = ARGV[0...-1]
+abort "must specify path to vim-declarations.xml" if XML_FNS.empty?
+OUT_FN = ARGV[-1] or abort "must specify path to output database"
+
+XML_FNS.each do |x|
+  abort "XML file #{x} does not exist" unless File.exists? x
+end
+
+TYPES = {}
+VERSIONS = []
+
+ID2NAME = Hash.new { |h,k| fail "unknown type-id #{k.inspect}" }
+
+ID2NAME.merge!({
+  'java.lang.String' => 'xsd:string',
+  'BOOLEAN' => 'xsd:boolean',
+  'BYTE' => 'xsd:byte',
+  'SHORT' => 'xsd:short',
+  'INT' => 'xsd:int',
+  'LONG' => 'xsd:long',
+  'FLOAT' => 'xsd:float',
+  'DOUBLE' => 'xsd:double',
+  'vmodl.DateTime' => 'xsd:dateTime',
+  'vmodl.Binary' => 'xsd:base64Binary',
+  'vmodl.Any' => 'xsd:anyType',
+  'void' => nil,
+})
+
+%w(DataObject ManagedObject MethodFault MethodName
+   PropertyPath RuntimeFault TypeName).each do |x|
+  ID2NAME['vmodl.' + x] = x
+end
+
+def handle_data_object node
+  if TYPES[node['name']]
+    puts "Type #{node['name']} already exists"
+    return
+  end
+
+  ID2NAME[node['type-id']] = node['name']
+  TYPES[node['name']] = {
+    'kind' => 'data',
+    'base-type-id' => node['base-type-id'],
+    'props' => node.children.select { |x| x.name == 'property' }.map do |property|
+      {
+        'name' => property['name'],
+        'type-id-ref' => property['type-id-ref'],
+        'is-optional' => property['is-optional'] ? true : false,
+        'is-array' => property['is-array'] ? true : false,
+        'version-id-ref' => property['version-id-ref'],
+      }
+    end
+  }
+end
+
+def handle_managed_object node
+  if TYPES[node['name']]
+    puts "Type #{node['name']} already exists"
+    return
+  end
+  ID2NAME[node['type-id']] = node['name']
+  TYPES[node['name']] = {
+    'kind' => 'managed',
+    'base-type-id' => node['base-type-id'],
+    'props' => node.children.select { |x| x.name == 'property' }.map do |property|
+      {
+        'name' => property['name'],
+        'type-id-ref' => property['type-id-ref'],
+        'is-optional' => property['is-optional'] ? true : false,
+        'is-array' => property['is-array'] ? true : false,
+        'version-id-ref' => property['version-id-ref'],
+      }
+    end,
+    'methods' => Hash[
+      node.children.select { |x| x.name == 'method' }.map do |method|
+        [method['is-task'] ? "#{method['name']}_Task" : method['name'],
+         {
+           'params' => method.children.select { |x| x.name == 'parameter' }.map do |param|
+             {
+               'name' => param['name'],
+               'type-id-ref' => param['type-id-ref'],
+               'is-array' => param['is-array'] ? true : false,
+               'is-optional' => param['is-optional'] ? true : false,
+               'version-id-ref' => param['version-id-ref'],
+             }
+           end,
+           'result' => {
+             'type-id-ref' => method['type-id-ref'],
+             'is-array' => method['is-array'] ? true : false,
+             'is-optional' => method['is-optional'] ? true : false,
+             'is-task' => method['is-task'] ? true : false,
+             'version-id-ref' => method['version-id-ref'],
+           }
+         }
+        ]
+      end
+    ]
+  }
+end
+
+def handle_enum node
+  if TYPES[node['name']]
+    puts "Type #{node['name']} already exists"
+    return
+  end
+
+  ID2NAME[node['type-id']] = node['name']
+  TYPES[node['name']] = {
+    'kind' => 'enum',
+    'values' => node.children.map { |child| child['name'] },
+  }
+end
+
+def handle_fault node
+  handle_data_object node
+end
+
+def handle_version x
+  attrs = %w(display-name name service-namespace type-id version-id vmodl-name)
+  h = Hash[attrs.map { |k| [k, x[k]] }]
+  h['compatible'] = x.children.select(&:element?).map { |y| y.text }
+  VERSIONS << h
+end
+
+XML_FNS.each do |fn|
+  puts "parsing #{fn} ..."
+  xml = Nokogiri.parse(File.read(fn), nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS)
+  xml.root.at('enums').children.each { |x| handle_enum x }
+  xml.root.at('managed-objects').children.each { |x| handle_managed_object x }
+  xml.root.at('data-objects').children.each { |x| handle_data_object x }
+  xml.root.at('faults').children.each { |x| handle_fault x }
+  #xml.root.at('definitions').at('version-types').children.each { |x| handle_version x }
+end
+
+munge_fault = lambda { |x| true }
+
+TYPES.each do |k,t|
+  case t['kind']
+  when 'data'
+    t['wsdl_base'] = t['base-type-id'] ? ID2NAME[t['base-type-id']] : 'DataObject'
+    t.delete 'base-type-id'
+    t['props'].each do |x|
+      x['wsdl_type'] = ID2NAME[x['type-id-ref']]
+      x.delete 'type-id-ref'
+      munge_fault[x]
+    end
+  when 'managed'
+    t['wsdl_base'] = t['base-type-id'] ? ID2NAME[t['base-type-id']] : 'ManagedObject'
+    t.delete 'base-type-id'
+    t['props'].each do |x|
+      x['wsdl_type'] = ID2NAME[x['type-id-ref']]
+      x.delete 'type-id-ref'
+      munge_fault[x]
+    end
+    t['methods'].each do |mName,x|
+      if y = x['result']
+        y['wsdl_type'] = ID2NAME[y['type-id-ref']]
+        y.delete 'type-id-ref'
+        munge_fault[y]
+      end
+      x['params'].each do |r|
+        r['wsdl_type'] = ID2NAME[r['type-id-ref']]
+        r.delete 'type-id-ref'
+        munge_fault[r]
+      end
+    end
+  when 'enum'
+  else fail
+  end
+end
+
+db = {}
+
+TYPES.each do |k,t|
+  db[k] = t
+end
+
+db['_typenames'] = TYPES.keys
+db['_versions'] = VERSIONS
+
+File.open(OUT_FN, 'w') { |io| Marshal.dump db, io }
+
+if filename = ENV['VERSION_GRAPH']
+  File.open(filename, 'w') do |io|
+    io.puts "digraph versions\n{"
+    VERSIONS.each do |h|
+      io.puts "\"#{h['vmodl-name']}\" [label=\"#{h['vmodl-name']} (#{h['version-id']})\"]"
+      h['compatible'].each do |x|
+        x =~ /^interface / or fail x
+        io.puts "\"#{h['vmodl-name']}\" -> \"#{$'}\""
+      end
+    end
+    io.puts "}\n"
+  end
+end

data/devel/analyze-xml.rb

@@ -0,0 +1,46 @@
+require 'nokogiri'
+
+# removes line breaks and whitespace between xml nodes.
+def prepare_xml(xml)
+  xml = xml.gsub(/\n+/, "")
+  xml = xml.gsub(/(>)\s*(<)/, '\1\2')
+end
+
+def analyze_xml x, tree
+  subtree = (tree[x.name] ||= { :attributes => [], :min_occur => nil, :max_occur => nil })
+  attrs = x.attributes.keys.sort
+  subtree[:attributes] << attrs unless subtree[:attributes].member? attrs
+
+  child_occurs = Hash.new 0
+  x.children.select(&:element?).each do |c|
+    child_occurs[c.name] += 1
+    analyze_xml c, subtree
+  end
+
+  subtree.select { |k,v| k.is_a? String }.each do |k,v|
+    v[:min_occur] = [v[:min_occur], child_occurs[k]].compact.min
+    v[:max_occur] = [v[:max_occur], child_occurs[k]].compact.max
+  end
+end
+
+def print_tree tree, indent=0
+  tree.select { |k,v| k.is_a? String }.sort.each do |k,v|
+    attrs = v[:attributes] || []
+    min, max = v[:min_occur], v[:max_occur]
+    numsym = if min == 0 and max == 0 then fail
+             elsif min == 0 and max == 1 then '?'
+             elsif min == 0 then '*'
+             elsif min == 1 and max == 1 then ''
+             else '+'
+             end
+    puts "#{'  '*indent}#{k}#{numsym}: #{attrs.sort.map { |a| "[#{a * ' '}]"} * ', '} {#{min},#{max}}"
+    print_tree v, (indent+1)
+  end
+end
+
+tree = {}
+ARGV.each do |fn|
+  nk = Nokogiri(prepare_xml(File.read fn))
+  analyze_xml nk.root, tree
+end
+print_tree tree

data/devel/benchmark.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+require 'tempfile'
+
+if ENV['RBVMOMI_COVERAGE'] == '1'
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'rbvmomi'
+require 'rbvmomi/deserialization'
+require 'benchmark'
+require 'libxml'
+
+NS_XSI = 'http://www.w3.org/2001/XMLSchema-instance'
+
+VIM = RbVmomi::VIM
+$conn = VIM.new(:ns => 'urn:vim25', :rev => '4.0')
+raw = File.read(ARGV[0])
+
+def diff a, b
+  a_io = Tempfile.new 'rbvmomi-diff-a'
+  b_io = Tempfile.new 'rbvmomi-diff-b'
+  PP.pp a, a_io
+  PP.pp b, b_io
+  a_io.close
+  b_io.close
+  system("diff -u #{a_io.path} #{b_io.path}")
+  a_io.unlink
+  b_io.unlink
+end
+
+begin
+  deserializer = RbVmomi::OldDeserializer.new($conn)
+  end_time = Time.now + 1
+  n = 0
+  while n == 0 or end_time > Time.now
+    deserializer.deserialize Nokogiri::XML(raw).root
+    n += 1
+  end
+  N = n*10
+end
+
+puts "iterations: #{N}"
+
+parsed_nokogiri = Nokogiri::XML(raw)
+parsed_libxml = LibXML::XML::Parser.string(raw).parse
+
+if true
+  nokogiri_xml = parsed_nokogiri.root
+  libxml_xml = parsed_libxml.root
+
+  old_nokogiri_result = RbVmomi::OldDeserializer.new($conn).deserialize nokogiri_xml
+  new_nokogiri_result = RbVmomi::NewDeserializer.new($conn).deserialize nokogiri_xml
+  new_libxml_result = RbVmomi::NewDeserializer.new($conn).deserialize libxml_xml
+
+  if new_nokogiri_result != old_nokogiri_result
+    puts "new_nokogiri_result doesnt match old_nokogiri_result"
+    puts "old_nokogiri_result:"
+    pp old_nokogiri_result
+    puts "new_nokogiri_result:"
+    pp new_nokogiri_result
+    puts "diff:"
+    diff old_nokogiri_result, new_nokogiri_result
+    exit 1
+  end
+
+  if new_libxml_result != old_nokogiri_result
+    puts "new_libxml_result doesnt match old_nokogiri_result"
+    puts "old_nokogiri_result:"
+    pp old_nokogiri_result
+    puts "new_libxml_result:"
+    pp new_libxml_result
+    puts "diff:"
+    diff old_nokogiri_result, new_libxml_result
+    exit 1
+  end
+
+  puts "all results match"
+end
+
+Benchmark.bmbm do|b|
+  GC.start
+  b.report("nokogiri parsing") do
+    N.times { Nokogiri::XML(raw) }
+  end
+  
+  GC.start
+  b.report("libxml parsing") do
+    N.times do
+      LibXML::XML::Parser.string(raw).parse
+    end
+  end
+  
+  GC.start
+  b.report("old deserialization (nokogiri)") do
+    deserializer = RbVmomi::OldDeserializer.new($conn)
+    N.times do
+      deserializer.deserialize Nokogiri::XML(raw).root
+    end
+  end
+
+  GC.start
+  b.report("new deserialization (nokogiri)") do
+    deserializer = RbVmomi::NewDeserializer.new($conn)
+    N.times do
+      deserializer.deserialize Nokogiri::XML(raw).root
+    end
+  end
+
+  GC.start
+  b.report("new deserialization (libxml)") do
+    deserializer = RbVmomi::NewDeserializer.new($conn)
+    N.times do
+      deserializer.deserialize LibXML::XML::Parser.string(raw).parse.root
+    end
+  end
+end

data/devel/collisions.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# Find collisions between VMODL property names and Ruby methods
+require 'rbvmomi'
+VIM = RbVmomi::VIM
+
+conn = VIM.new(:ns => 'urn:vim25', :rev => '4.0')
+
+VIM.loader.typenames.each do |name|
+  klass = VIM.loader.get name
+  next unless klass.respond_to? :kind and [:managed, :data].member? klass.kind
+  methods = klass.kind == :managed ?
+    RbVmomi::BasicTypes::ObjectWithMethods.instance_methods : 
+    RbVmomi::BasicTypes::ObjectWithProperties.instance_methods
+  klass.props_desc.each do |x|
+    name = x['name']
+    puts "collision: #{klass}##{name}" if methods.member? name.to_sym
+  end
+end