dtk_crd_parser 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e69f417b48d667384312f79a580f591788d3e677
+  data.tar.gz: e77320a777a0c480e2defc94db3c3660796215bf
+SHA512:
+  metadata.gz: 7009538c93dc66dcaa01df238cef75eeea2b0d057582c24a6dff709c48cfac148dea0bb11f7f2503c08f7ac4a85b7137a76fc761cbe3f1a99c12b31a9b8ebe11
+  data.tar.gz: c19e34dad7e41474b19460ad95efba219b4ba4c9d952605460209f0afc6bfbb25c0e94bbe85e94452d6f03606b98710ef7f7ec379b180b11f66c830dfa059ff3

data/lib/crd_parser/base_class/helper_mixins.rb

@@ -0,0 +1,52 @@
+module DTK::CrdParser
+  class BaseClass
+    module Helper
+      module ClassAndInstanceMixin
+        # Helper functions want to have available in all classes
+
+        def fail_if_not_type(object, type)
+          if object.kind_of?(type)
+            object
+          else
+            fail "Expected a #{type}, but given a '#{object.class}'"
+          end
+        end
+
+        def fail_if_not_concrete(parent)
+          klass = (parent.kind_of?(::Module) ? parent : parent.class)
+          the_method = "The method"
+          if caller.first =~ /in `(.+)'/
+            method_name = $1
+            the_method << " '#{method_name}'"
+          end
+          fail "#{the_method} is not defined in the concrete class #{klass}"
+        end
+        
+        def isOnSpecificNode(actionComponent)
+        	actionComponent.include? "/"
+      	end
+
+        def destructureActionComponent(actionComponent)
+          # regex to match component: module::name[attrName].action
+          regex = /(.*)::(.*)\[(.*)\].?(.*)/
+          # if component on node group node, get full name first
+          # i.e ec2::node[ng-1]/(node-utility::ssh-access[ubuntu])
+          nodeName, actionComponent = actionComponent.match(/(.*)\/(.*)/).captures if isOnSpecificNode(actionComponent)
+          compModule, compName, attributeName, action = actionComponent.match(regex).captures
+          action = !action.empty? ? action.to_sym : :create
+      
+          if(compModule.nil? || compName.nil? || attributeName.nil?)
+              raise `Could not resolve component module, name or attribute name for component: #{actionComponent}`
+          end
+          {
+            moduleName: compModule,
+            componentName: compName,
+            attributeName: attributeName,
+            action: action
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/crd_parser/base_class.rb

@@ -0,0 +1,8 @@
+module DTK::CrdParser
+  class BaseClass
+    require_relative('base_class/helper_mixins')
+
+    include Helper::ClassAndInstanceMixin
+    extend  Helper::ClassAndInstanceMixin
+  end
+end

data/lib/crd_parser/component/attribute.rb

@@ -0,0 +1,18 @@
+module DTK::CrdParser
+  class Component 
+    class Attribute < BaseClass
+      def initialize(name, value)
+        @name      = name
+        @value     = value
+      end
+
+      def self.create_from_kube(attribute)
+        new Attribute(attribute[:name], attribute[:value])
+      end
+
+      protected
+
+      attr_reader :name, :value
+    end
+  end
+end

data/lib/crd_parser/component.rb

@@ -0,0 +1,45 @@
+module DTK::CrdParser
+  class Component < BaseClass
+    require_relative('component/attribute')
+
+    MODE_DEFAULT = :component_instance
+    def initialize(name, component_def, attributes)
+      @name          = name
+      @component_def = component_def # this wil point to the corresponding component def
+      @attributes    = attributes # array that has an Attribute object for each attribute; these are name-value pairs
+    end
+
+    def self.create_from_kube(client, component_instance, component_name)
+      puts component_instance
+      unless client.discovered
+        client.discover
+      end
+      puts client.methods - Object.methods
+      component_instance_obj = client.get_component(component_instance[:name], component_instance[:namespace])
+      puts component_instance_obj
+      component_def = ComponentDef.create_from_kube(client, component_instance_obj, component_name)
+      component_attributes = getComponentAttributes(component_name, component_instance_obj[:spec][:components])
+      attributes = []
+      component_attributes.each do |attr|
+        attributes.push Attribute.create_from_kube(attr)
+      end
+			Component.new(component_name, component_def, attributes)
+    end
+
+    protected
+
+    def self.getComponentAttributes(fullComponentName, components)
+      fullComponentName.gsub!('_', '-')
+      component = components.each do |component|
+        componentObj = component[fullComponentName]
+        if(componentObj && componentObj.is_a?(Kubeclient::Resource))
+          return componentObj[:attributes]
+        end
+      end
+      return nil
+    end
+
+    attr_reader :name, :component_def, :attributes
+
+  end
+end

data/lib/crd_parser/component_def/attribute_type_info.rb

@@ -0,0 +1,20 @@
+module DTK::CrdParser
+  class ComponentDef 
+    class AttributeTypeInfo < BaseClass
+      def initialize(params)
+        @name      = params[:name]
+        @type      = params[:type]
+        @required  = params[:required] || false
+        @dynamic   = params[:dynamic]  || false
+      end
+
+      def self.resolveAttr(attribute)
+        new AttributeTypeInfo(attribute)
+      end
+
+      protected
+
+      attr_reader :name
+    end
+  end
+end

data/lib/crd_parser/component_def.rb

@@ -0,0 +1,60 @@
+module DTK::CrdParser
+  class ComponentDef < BaseClass
+      require_relative('component_def/attribute_type_info')
+
+      MODE_DEFAULT = :component_instance
+
+      def initialize(metadata, componentDefAction, componentDefAttributes)
+        @name = metadata[:name]
+        @namespace = metadata[:namespace]
+        @resourceVersion = metadata[:resourceVersion]
+
+        @bash_script = componentDefAction[:bash_script]
+        @entrypoint  = componentDefAction[:entrypoint]
+        @type        = componentDefAction[:type]
+
+        @attribute_type_info  = componentDefAttributes
+      end
+
+      def self.create_from_kube(client, component_instance, component_def_name)
+        puts 'COMPONENT DEF'
+        module_ref   = resolveModuleReference(component_instance.module_refs, component_def_name, destructureActionComponent(component_def_name)[:moduleName])
+        componentDef = client.get_componentdef(component_def_name, module_ref[:namespace])
+        
+        name            = componentDef[:metadata][:name]
+        namespace       = componentDef[:metadata][:namespace]
+        resourceVersion = componentDef[:metadata][:namespace]
+
+        componentDefSpec       = componentDef[:spec]
+        componentDefAction     = componentDefSpec[:actions][component.action.to_sym]
+        componentDefAttributes = []
+    
+        componentDefSpec[:attributes].each do |attribute| 
+          componentDefAttributes.push AttributeTypeInfo.resolveAttr(attribute)
+        end
+
+        metadata = {
+          name: name, 
+          namespace: namespace, 
+          resourceVersion: resourceVersion
+        }
+
+        ComponentDef.new(metadata, componentDefAction, componentDefAttributes)  
+      end
+
+      private
+
+      def self.resolveModuleReference(module_refs, component_full_name, module_name)
+        module_ref = module_refs.find { |module_ref| module_ref[:name].gsub!('_', '-') == module_name.gsub!('_', '-') }
+        if(module_ref.nil?)
+          raise "Could not resolve module reference for component #{component_full_name} in component instance. Expected to find: #{module_name}"
+        end
+        module_ref
+      end
+
+      protected
+
+      attr_reader :name, :namespace, :attribute_type_info, :bash_script, :entrypoint, :type
+    
+  end
+end

data/lib/crd_parser.rb

@@ -0,0 +1,15 @@
+module DTK
+  module DTK::CrdParser
+      require_relative('crd_parser/base_class')
+    
+      require_relative('crd_parser/component')
+      require_relative('crd_parser/component_def')
+    
+      def self.parse_crd_to_component(client, component_instance, component_name) 
+        #component instance has a name and a namespace
+        #client is kube client
+        #component name is, for example, network-aws::vpc[vpc1]
+        Component.create_from_kube(client, component_instance, component_name)
+      end
+    end
+  end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: dtk_crd_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- DTK
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-28 00:00:00.000000000 Z
+dependencies: []
+description: Parse kubernetes DTK crd to ruby in memory object
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/crd_parser.rb
+- lib/crd_parser/base_class.rb
+- lib/crd_parser/base_class/helper_mixins.rb
+- lib/crd_parser/component.rb
+- lib/crd_parser/component/attribute.rb
+- lib/crd_parser/component_def.rb
+- lib/crd_parser/component_def/attribute_type_info.rb
+homepage: https://rubygems.org/gems/dtk_crd_parser
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: Parse kubernetes DTK crd to ruby in memory object!
+test_files: []