loe-iclassify-interface 1.0.0

data/History.txt

@@ -0,0 +1,5 @@
+=== 1.0.0 / 2008-12-08
+
+* 1 major enhancement
+
+  * Birthday!

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+iclassify-interface.gemspec
+lib/iclassify-interface.rb
+lib/iclassify-interface/agent.rb
+lib/iclassify-interface/client.rb
+lib/iclassify-interface/node.rb
+lib/iclassify-interface/version.rb
+test/test_iclassify-interface.rb

data/README.txt

@@ -0,0 +1,36 @@
+= iclassify-interface
+
+http://github.com/loe/iclassify-interface
+
+== DESCRIPTION:
+
+Module for interfacing with iclassify.
+
+== INSTALL:
+
+sudo gem install loe-iclassify-interface
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIX
+
+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/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'hoe'
+
+LIB_DIR = File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
+$LOAD_PATH << LIB_DIR
+
+require 'iclassify-interface/version'
+
+HOE = Hoe.new('iclassify-interface', IClassify::VERSION) do |p|
+  p.name = "iclassify-interface"
+  p.author = "W. Andrew Loe III"
+  p.email = "loe@onehub.com"
+  p.summary = "Module for interfacing with an iclassify server."
+end
+
+# Cribbed from nokogiri
+namespace :gem do
+  task :spec do
+    File.open("#{HOE.name}.gemspec", 'w') do |f|
+      f.write(HOE.spec.to_ruby)
+    end
+  end
+end

data/iclassify-interface.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |s|
+  s.name = %q{iclassify-interface}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["W. Andrew Loe III"]
+  s.date = %q{2008-12-08}
+  s.description = %q{Module for interfacing with iclassify.}
+  s.email = %q{loe@onehub.com}
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "iclassify-interface.gemspec", "lib/iclassify-interface.rb", "lib/iclassify-interface/agent.rb", "lib/iclassify-interface/client.rb", "lib/iclassify-interface/node.rb", "lib/iclassify-interface/version.rb", "test/test_iclassify-interface.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/loe/iclassify-interface}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{iclassify-interface}
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{Module for interfacing with an iclassify server.}
+  s.test_files = ["test/test_iclassify-interface.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if current_version >= 3 then
+      s.add_development_dependency(%q<hoe>, [">= 1.8.2"])
+    else
+      s.add_dependency(%q<hoe>, [">= 1.8.2"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 1.8.2"])
+  end
+end

data/lib/iclassify-interface.rb

@@ -0,0 +1,4 @@
+require 'iclassify-interface/agent'
+require 'iclassify-interface/client'
+require 'iclassify-interface/node'
+require 'iclassify-interface/version'

data/lib/iclassify-interface/agent.rb

@@ -0,0 +1,155 @@
+require 'rubygems'
+require 'uuidtools'
+
+module IClassify
+  class Agent
+    attr_accessor :node
+    attr_accessor :uuid
+    attr_accessor :password
+    
+    #
+    # Create a new Agent.  Takes a path to a file to either read or drop
+    # a UUID, and a server URL.
+    #
+    def initialize(uuidfile="/etc/icagent/icagent.uuid", server_url="http://localhost:3000")
+      @uuid = nil
+      @password = nil
+      if File.exists?(uuidfile)
+        IO.foreach(uuidfile) do |line|
+          @uuid, @password = line.chomp.split("!")
+        end
+        unless @password
+          @password = random_password(30)
+          write_uuidfile(uuidfile)
+        end
+      else
+        @uuid = UUID.random_create
+        @password = random_password(30)
+        write_uuidfile(uuidfile)
+      end
+      @client = IClassify::Client.new(server_url, @uuid, @password)
+    end
+    
+    #
+    # Loads data about this node from the iClassify service
+    #
+    def load
+      begin 
+        @node = @client.get_node(@uuid)
+      rescue Net::HTTPServerException => e
+        if e.to_s =~ /^404/
+          @node = IClassify::Node.new()
+          @node.description = "New Node"
+          @node.tags << "unclassified"
+          @node.password = @password
+          @node.uuid = @uuid
+        else
+          throw(e)
+        end
+      end
+    end
+    
+    # 
+    # Updates this node in the iClassify service.
+    #
+    def update
+      if @node.description == "New Node"
+        hostname = attrib?("hostname")
+        hostname ||= "New Node"
+        @node.description = hostname
+      end
+      @client.update_node(@node)
+    end 
+    
+    # 
+    # Deletes this node from the iClassify service.
+    #
+    def delete
+      @client.delete_node(@node)
+    end
+    
+    #
+    # Returns the tag name if this node has that tag.
+    #
+    def tag?(tag)
+      @node.tag?(tag)
+    end
+    
+    # Returns the values for this attribute, if it exists for this node.  If
+    # there is only one, it will return it, if it's an array, you get the 
+    # array. You have to check!
+    def attrib?(attrib)
+      @node.attrib?(attrib)
+    end
+    
+    # Returns the current node as a string.
+    def to_s
+      @node.to_s
+    end
+    
+    # Returns the value if the given attribute has a given attribute.
+    def attrib_has_value?(attrib, value)
+      na = @node.attribs.detect { |a| a[:name] == attrib }
+      if na 
+        return na.values.detect { |v| v == value}
+      else
+        return nil
+      end
+    end
+    
+    # Add a tag to this node.
+    def add_tag(tag)
+      load unless @node
+      @node.tags << tag
+    end
+    
+    # Add an attribute to this node. Requires a name and either a string or
+    # array of values.
+    #
+    # Will be cumulative!
+    def add_attrib(name, values)
+      load unless @node
+      @node.attribs << { :name => name, :values => values.kind_of?(Array) ? values : [ values ] }
+    end
+    
+    # Replace the attribute with the given name's values in place.
+    # Will add a new attribute if it needs to.
+    def replace_attrib(name, values)
+      exists = @node.attribs.detect { |a| a[:name] == name }
+      if exists
+        exists[:values] = values.kind_of?(Array) ? values : [ values ]
+      else
+        add_attrib(name, values)
+      end
+    end
+    
+    # Set the description for the node
+    def description(value)
+      @node.description = value
+    end
+
+    # return the value of @node.description
+    def description?()
+      @node.description
+    end
+
+    # Run an iclassify script.
+    def run_script(scriptfile)
+      eval(IO.read(scriptfile))
+    end
+    
+    protected
+      def random_password(len)
+        chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+        newpass = ""
+        1.upto(len) { |i| newpass << chars[rand(chars.size-1)] }
+        newpass
+      end 
+      
+      def write_uuidfile(uuidfile)
+        File.open(uuidfile, "w") do |file|
+          file.puts "#{@uuid}!#{@password}"
+        end
+      end
+  end
+end

data/lib/iclassify-interface/client.rb

@@ -0,0 +1,108 @@
+require 'rubygems'
+require 'net/https'
+require 'rexml/document'
+require 'uri'
+require 'yaml'
+
+module IClassify
+
+  class Client 
+     UUID_REGEX = /^[[:xdigit:]]{8}[:-][[:xdigit:]]{4}[:-][[:xdigit:]]{4}[:-][[:xdigit:]]{4}[:-][[:xdigit:]]{12}$/
+  
+    def initialize(service_url, username, password)
+      service_url = "#{service_url}/rest" unless service_url =~ /rest$/
+      @url = URI.parse(service_url)
+      @username = username
+      @password = password
+    end
+  
+    def make_url(method, params)
+      params[:appid] = @appid
+      super method, params
+    end
+
+    def search(query, attribs=[])
+      raise ArgumentError, "Attributes must be given as a list!" unless attribs.kind_of?(Array)
+      querystring = "search"
+      querystring << "?q=#{URI.escape(query)}"
+      querystring << "&a=#{URI.escape(attribs.join(','))}" if attribs.length > 0
+      results = get_rest(querystring, "text/yaml")
+      node_array = YAML.load(results).collect { |n| IClassify::Node.new(:yaml, n) }
+    end
+    
+    def get_node(node_id)
+      IClassify::Node.new(:xml, get_rest("nodes/#{node_id}"))
+    end
+    
+    def update_node(node)
+      if node.node_id
+        put_rest("nodes/#{node.node_id}", node.to_xml)
+      else
+        post_rest("nodes", node.to_xml)
+      end
+    end
+    
+    def delete_node(node)
+      delete_rest("nodes/#{node.node_id}")
+    end
+  
+    private
+    
+      def get_rest(path, accept="application/xml")
+        url = URI.parse("#{@url}/#{path}")
+        run_request(:GET, url, false, accept)    
+      end                               
+                                        
+      def delete_rest(path, accept="application/xml")             
+        url = URI.parse("#{@url}/#{path}")
+        run_request(:DELETE, url, false, accept)       
+      end                               
+                                        
+      def post_rest(path, xml, accept="application/xml")          
+        url = URI.parse("#{@url}/#{path}")
+        run_request(:POST, url, xml, accept)    
+      end                               
+                                        
+      def put_rest(path, xml, accept="application/xml")           
+        url = URI.parse("#{@url}/#{path}")
+        run_request(:PUT, url, xml, accept)
+      end
+      
+      def run_request(method, url, data=false, accept="application/xml")
+        http = Net::HTTP.new(url.host, url.port)
+        if url.scheme == "https"
+          http.use_ssl = true 
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        http.read_timeout = 60
+        headers = { 
+          'Accept' => accept,
+          'Content-Type' => accept
+        }
+        req = nil
+        case method
+        when :GET
+          req_path = "#{url.path}"
+          req_path << "?#{url.query}" if url.query
+          req = Net::HTTP::Get.new(req_path, headers)
+        when :POST
+          req = Net::HTTP::Post.new(url.path, headers)
+          req.body = data if data
+        when :PUT
+          req = Net::HTTP::Put.new(url.path, headers)
+          req.body = data if data
+        when :DELETE
+          req = Net::HTTP::Delete.new(url.path, headers)
+        end
+        req.basic_auth(@username, @password)
+        res = http.request(req)
+        case res
+        when Net::HTTPSuccess
+          res.body
+        else
+          res.error!
+        end
+      end
+        
+  end
+end

data/lib/iclassify-interface/node.rb

@@ -0,0 +1,134 @@
+require 'rubygems'
+require 'rexml/document'
+require 'builder'
+require 'yaml'
+require 'digest/sha1'
+
+module IClassify
+  class Node
+    attr_accessor :tags, :uuid, :description, :notes, :attribs, :node_id, :password
+    
+    def initialize(type=:xml, data=nil)
+      from_xml(data) if type == :xml && data
+      from_yaml(data) if type == :yaml && data
+      @tags ||= Array.new
+      @attribs ||= Array.new
+      @password = nil
+    end
+    
+    def to_xml
+      xml = Builder::XmlMarkup.new
+      output = xml.node do
+        xml.id(@node_id) if @node_id
+        xml.uuid(@uuid)
+        xml.password(@password) if @password
+        xml.description(@description)
+        xml.notes(@notes)
+        xml.tags do
+          @tags.sort.each do |tag|
+            xml.tag(tag)
+          end
+        end
+        xml.attribs do
+          @attribs.sort{ |a,b| a[:name] <=> b[:name] }.each do |attrib|
+            xml.attrib do
+              xml.name(attrib[:name])
+              xml.values do
+                attrib[:values].each do |v|
+                  xml.value(v)
+                end
+              end
+            end
+          end
+        end
+      end
+      output
+    end
+    
+    def digest
+       Digest::SHA1.hexdigest(to_s())
+    end
+    
+    #
+    # Returns the tag name if this node has that tag.
+    #
+    def tag?(tag)
+      @tags.detect { |t| t == tag }
+    end
+    
+    # Returns the values for this attribute, if it exists for this node.  If
+    # there is only one, it will return it, if it's an array, you get the 
+    # array. You have to check!
+    def attrib?(attrib)
+      na = @attribs.detect { |a| a[:name] == attrib }
+      return nil unless na
+      if na[:values].length > 1
+        return na[:values]
+      else
+        return na[:values][0]
+      end
+    end
+    
+    def to_s(tags=nil,attribs=[])
+      output = String.new
+      output << "uuid: #{@uuid}\n"
+      output << "node_id: #{@node_id}\n"
+      output << "notes: #{@notes}\n"
+      output << "description: #{@description}\n"
+      output << "tags: #{@tags.sort.join(' ')}\n"
+      output << "attribs:\n"
+      @attribs.select{ |attrib| attribs.include?(attrib[:name].to_sym) }.sort{ |a,b| a[:name] <=> b[:name] }.each do |attrib|
+        output << "  #{attrib[:name]}: #{attrib[:values].join(', ')}\n"
+      end
+      output
+    end
+    
+    def to_puppet
+      output = Hash.new
+      output["classes"] = @tags
+      output["parameters"] = Hash.new
+      @attribs.each do |attrib|
+        if attrib[:values].length > 1
+          output["parameters"][attrib[:name]] = attrib[:values]
+        else
+          output["parameters"][attrib[:name]] = attrib[:values][0]
+        end
+      end
+      output.to_yaml
+    end
+        
+    def from_xml(doc)
+      xml = nil
+      if doc.kind_of?(REXML::Element)
+        xml = doc
+      else
+        xml = REXML::Document.new(doc)
+      end
+      @tags = Array.new
+      xml.elements.each('//tag') { |t| @tags << t.text }
+      @uuid = xml.get_text('//uuid')
+      @node_id   = xml.get_text('//id')
+      @description = xml.get_text('//description')
+      @notes = xml.get_text('//notes')
+      @attribs = Array.new
+      xml.elements.each('//attrib') do |attrib|
+        cattrib = Hash.new
+        cattrib[:name] = attrib.get_text('name').to_s
+        value_array = Array.new
+        attrib.elements.each('values/value') { |v| value_array << v.text }
+        cattrib[:values] = value_array 
+        @attribs << cattrib
+      end
+    end
+    
+    def from_yaml(data)
+      @tags = data[:tags].collect { |t| t[:name] }
+      @uuid = data[:uuid]
+      @description = data[:description]
+      @notes = data[:notes]
+      @attribs = data[:attribs].delete_if { |x| x[:name] == "text" }
+      @node_id = data[:id]
+    end
+      
+  end
+end

data/lib/iclassify-interface/version.rb

@@ -0,0 +1,3 @@
+module IClassify
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: loe-iclassify-interface
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- W. Andrew Loe III
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-08 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: Module for interfacing with iclassify.
+email: loe@onehub.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- iclassify-interface.gemspec
+- lib/iclassify-interface.rb
+- lib/iclassify-interface/agent.rb
+- lib/iclassify-interface/client.rb
+- lib/iclassify-interface/node.rb
+- lib/iclassify-interface/version.rb
+- test/test_iclassify-interface.rb
+has_rdoc: true
+homepage: http://github.com/loe/iclassify-interface
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: iclassify-interface
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Module for interfacing with an iclassify server.
+test_files: 
+- test/test_iclassify-interface.rb