gprov 0.0.3

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright 2011 Puppet Labs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

data/README.markdown

@@ -0,0 +1,7 @@
+Ruby-GProv
+==========
+
+Description
+-----------
+
+Ruby implementation of the [Google Provisioning API](http://code.google.com/googleapps/domain/gdata_provisioning_api_v2.0_reference.html).

data/Rakefile

@@ -0,0 +1,5 @@
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
+require 'gprov'
+Dir["tasks/rake/**/*"].each do |rakefile|
+  load rakefile
+end

data/lib/gprov.rb

@@ -0,0 +1,4 @@
+require 'gprov/version'
+require 'gprov/auth'
+require 'gprov/connection'
+require 'gprov/provision'

data/lib/gprov/auth.rb

@@ -0,0 +1 @@
+require 'gprov/auth/clientlogin'

data/lib/gprov/auth/clientlogin.rb

@@ -0,0 +1,65 @@
+# = gprov/auth/clientlogin.rb Implements the google clientLogin authentication method
+#
+# == Overview
+#
+# Implements the Google clientLogin method as documented in
+# http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'httparty'
+module GProv
+  module Auth
+    class ClientLogin
+      include HTTParty
+      base_uri 'https://www.google.com/accounts/ClientLogin'
+
+      # Instantiates a new ClientLogin object.
+      #
+      # Arguments:
+      #  * email: the email account to use for authentication
+      #  * password
+      #  * service: the Google service to generate authentication for
+      #  * options: An additional hash of parameters
+      #    * debug: turns on debug information for the request/response
+      #
+      # TODO make service an optional field
+      def initialize(email, password, service, options={})
+        @email    = email
+        @password = password
+        @service  = service
+        @options  = options
+
+        # additional options parsing
+        if @options[:debug]
+          self.class.debug_output $stderr
+        end
+      end
+
+      # Given an instantiated ClientLogin object, performs the actual 
+      # request/response handling of the authentication information.
+      #
+      # TODO More comprehensive error checking for this.
+      # TODO CAPTCHA handling
+      def token
+        form_data = {
+          "accountType" => "HOSTED",
+          "Email"       => @email,
+          "Passwd"      => @password,
+          "service"     => @service,
+        }
+
+        response = self.class.post('', {:body => form_data})
+        if response.code == 200 and response.body =~ /Auth=(.*)\n/
+          $1
+        end
+      end
+    end
+  end
+end

data/lib/gprov/connection.rb

@@ -0,0 +1,88 @@
+# = gprov/connection.rb: common interface for the google apps API
+#
+# == Overview
+#
+# Provides a single point of access for making http requests against the google
+# apps API.
+#
+# This adds the correct authorization header and content-type for make
+# requests against the google API work correctly, so that calling classes
+# don't need to handle authentication, formatting, or basic error handling.
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'httparty'
+require 'gprov/error'
+
+module GProv
+  class Connection
+    include HTTParty
+    base_uri "https://apps-apis.google.com/a/feeds/"
+
+    attr_reader :domain
+    def initialize(domain, token, options = {})
+      @domain = domain
+      @token  = token
+      @options = options
+
+      if @options[:debug]
+        self.class.debug_output $stderr
+      end
+    end
+
+    def default_headers
+      {:headers => {
+        'Authorization' => "GoogleLogin auth=#{@token}",
+        'Content-Type'  => 'application/atom+xml',
+      }}
+    end
+
+    # Forward instance level http methods to the class, after adding
+    # authorization and content-type information.
+    [:put, :get, :post, :delete].each do |verb|
+      define_method verb do |path, *args|
+
+        # Assign default arguments and validate passed arguments
+        if path.nil?
+          raise "#{self.class}##{verb} requires a non-nil path"
+        end
+        options = *args
+        options ||= {}
+        options.merge! default_headers
+
+        # Interpolate the :domain substring into a url to allow for the domain
+        # to be in an arbitary position of a request
+        path.gsub!(":domain", @domain)
+
+        if options[:noop] or @options[:noop]
+          $stderr.puts "Would have attempted the following call"
+          $stderr.puts "#{verb} #{path} #{options.inspect}"
+        else
+          # Return the request to the calling class so that the caller can
+          # determine the outcome of the request.
+          output = self.class.send(verb, path, options)
+          case output.code
+          when 401
+            raise GProv::Error::TokenInvalid.new(output)
+          when 403
+            raise GProv::Error::InputInvalid.new(output)
+          when 503
+            raise GProv::Error::QuotaExceeded.new(output)
+          else
+            if ! output.success?
+              raise GProv::Error.new(output)
+            else
+              output
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gprov/error.rb

@@ -0,0 +1,27 @@
+# = gprov/error.rb
+#
+# == Overview
+#
+# Common definition of possible gprov errors.
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'gprov'
+module GProv
+  class Error < Exception
+    attr_reader :request
+
+    def initialize(request = nil)
+      @request = request
+    end
+    class TokenInvalid < GProv::Error; end
+    class InputInvalid < GProv::Error; end
+    class QuotaExceeded < GProv::Error; end
+  end
+end

data/lib/gprov/provision.rb

@@ -0,0 +1,9 @@
+require 'gprov/provision/user'
+require 'gprov/provision/group'
+require 'gprov/provision/customerid'
+require 'gprov/provision/orgunit'
+
+module GProv
+  module Provision
+  end
+end

data/lib/gprov/provision/customerid.rb

@@ -0,0 +1,44 @@
+# = gprov/customerid.rb
+#
+# == Overview
+#
+# Retrieves a customerid string for an accompanying domain
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'gprov'
+require 'gprov/provision/entrybase'
+module GProv
+  module Provision
+    class CustomerID < GProv::Provision::EntryBase
+
+      xmlattr :customer_id, :xpath => %Q{apps:property[@name = "customerId"]/@value}
+      xmlattr :name,        :xpath => %Q{apps:property[@name = "name"]/@value}
+      xmlattr :description, :xpath => %Q{apps:property[@name = "description"]/@value}
+
+      xmlattr :customer_org_unit_name do
+        xpath %Q{apps:property[@name = "customerOrgUnitName"]/@value}
+      end
+
+      xmlattr :customer_org_unit_description do
+       xpath %Q{apps:property[@name = "customerOrgUnitDescription"]/@value}
+      end
+
+      def self.get(connection, options={})
+        response = connection.get("/customer/2.0/customerId")
+
+        document = Nokogiri::XML(response.body)
+        xml = document.root
+
+        new(:status => :clean, :connection => connection, :source => xml)
+      end
+    end
+  end
+end
+

data/lib/gprov/provision/entrybase.rb

@@ -0,0 +1,82 @@
+# = gprov/provision/entrybase.rb: base class for provisioning api objects
+#
+# == Overview
+#
+# Provides the top level constructs for mapping XML feeds to objects and back
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'nokogiri'
+require 'gprov/provision/entrybase/classmethods'
+module GProv
+  module Provision
+    class EntryBase
+
+      extend GProv::Provision::EntryBase::ClassMethods
+
+      # Status with respect to google.
+      # TODO protected?
+      # values: :new, :clean, :dirty, :deleted
+      attr_reader :status
+      attr_reader :connection
+
+      # Instantiates a new entry object.
+      #
+      # Possible data sources:
+      #  * Hash of attribute names and values
+      #  * A nokogiri node containing the root of the object
+      def initialize(opts={})
+
+        @status = (opts[:status] || :new)
+
+        if opts[:connection]
+          @connection = opts[:connection]
+        else
+          raise ArgumentError, "#{self.class}.new requires a connection parameter"
+        end
+
+        case source = opts[:source]
+        when Hash
+          attributes_from_hash source
+        when Nokogiri::XML::Node
+          hash = xml_to_hash(source)
+          attributes_from_hash hash
+        when NilClass
+          # New object!
+        else
+          raise
+        end
+      end
+
+      # Takes all xml_attr_accessors defined and an xml document and
+      # extracts the values from the xml into a hash.
+      def xml_to_hash(xml)
+        h = {}
+        if attrs = self.class.attributes
+          attrs.inject(h) do |hash, attr|
+            hash[attr.name] = attr.parse(xml)
+            hash
+          end
+        end
+        h
+      end
+
+      # Maps hash key/value pairs to object attributes
+      def attributes_from_hash(hash)
+        hash.each_pair do |k, v|
+          if respond_to? "#{k}=".intern
+            send("#{k}=".intern, v)
+          else
+            raise ArgumentError, %Q{Received invalid attribute "#{k}"}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gprov/provision/entrybase/classmethods.rb

@@ -0,0 +1,52 @@
+# = gprov/provision/entrybase/classmethods.rb
+#
+# == Overview
+#
+# Generates the DSL style behavior for entrybase and adds some convenience
+# methods
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'nokogiri'
+require 'gprov/provision/entrybase/xmlattr'
+module GProv
+  module Provision
+    class EntryBase
+      module ClassMethods
+        # Generates xmlattrs and encapsulates parsing logic
+        def xmlattr(name, options={}, &block)
+          attr = GProv::Provision::EntryBase::XMLAttr.new(name, options)
+          attr.instance_eval &block if block_given?
+          @attrs ||= []
+          @attrs << attr
+          attr_accessor name
+        end
+
+        # This is a class method because xmlattr objects are not directly
+        # exposed, so parsing needs to happen in the class.
+
+        # Provides an ordered list of xml attributes. Mainly used to give
+        # a list of attributes in a specific order.
+        def attributes
+          @attrs
+        end
+
+        def attribute_names
+          @attrs.map {|a| a.name }
+        end
+
+        # Transforms standard ruby attribute names to something slightly more
+        # human readable.
+        def attribute_titles
+          attribute_names.map {|f| f.to_s.capitalize.sub(/$/, ":").gsub(/_/, " ") }
+        end
+      end
+    end
+  end
+end

data/lib/gprov/provision/entrybase/xmlattr.rb

@@ -0,0 +1,92 @@
+# = gprov/provision/entrybase/xmlattr.rb: attribute accessors with xml annotations
+#
+# == Overview
+#
+# Defines a data type and provides the logic for extracting and formatting
+# object information from xml data
+#
+# Attribute accessors are not directly defined, because this class was designed
+# to be used DSL style
+#
+# == Examples
+#
+#     xmlattr :demo, :type => :numeric, :xpath => "example/xpath/text()"
+#
+#     xmlattr :demo do
+#       type :numeric
+#       xpath "example/xpath/text()"
+#     end
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'nokogiri'
+
+module GProv
+  module Provision
+    class EntryBase
+      class XMLAttr
+        attr_reader :name
+        def initialize(name, options={})
+          @name = name
+          @type = :string
+          methodhash(options)
+        end
+
+        def xpath(val=nil)
+          @xpath = val if val
+          @xpath
+        end
+
+        def type(val=nil)
+
+          if [:numeric, :string, :bool].include? val
+            @type = val
+          else
+            raise ArgumentException
+          end
+
+          @type
+        end
+
+        def parse(xml)
+          @value = xml.at_xpath(@xpath).to_s
+          format
+        end
+
+        private
+
+        def format
+          case @type
+          when :numeric
+            @value = @value.to_i
+          when :string
+            # no op
+          when :bool
+            if @value == "true"
+              @value = true
+            else # XXX sketchy
+              @value = false
+            end
+          end
+          @value
+        end
+
+        def methodhash(hash)
+          hash.each_pair do |method, value|
+            if respond_to? method
+              send method, value
+            else
+              raise ArgumentError, %Q{Received invalid attribute "#{method}"}
+            end
+          end
+        end
+      end
+    end
+  end
+end