gprov 0.0.3

data/lib/gprov/provision/feed.rb

@@ -0,0 +1,44 @@
+# Generic representation of the various types of feeds available from the
+# provisioning api
+require 'gprov'
+require 'nokogiri'
+
+module GProv
+  module Provision
+    class Feed
+
+      attr_reader :results
+      def initialize(connection, path, xpath)
+        @connection = connection
+        @url        = path
+        @xpath      = xpath
+
+        @results = []
+      end
+
+      def fetch
+        retrieve_page
+        @results
+      end
+
+      private
+
+      def retrieve_page
+        response = @connection.get(@url)
+
+        if response.code == 200
+          document = Nokogiri::XML(response.body)
+          entries = document.xpath(@xpath)
+
+          @results.concat(entries.to_a)
+        end
+      end
+
+      def retrieve_all
+        raise NotImplementedError
+      end
+
+    end
+  end
+end
+

data/lib/gprov/provision/group.rb

@@ -0,0 +1,147 @@
+# = gprov/provision/group.rb: implementation of the gprov provisioning groupentry
+#
+# == Overview
+#
+# implementation of the gprov provisioning groupentry
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'gprov'
+require 'gprov/provision/entrybase'
+require 'gprov/provision/member'
+require 'gprov/provision/owner'
+module GProv
+  module Provision
+    class Group < GProv::Provision::EntryBase
+
+      # TODO copy group_id on instantiation so that groups can change
+      # their IDs without exploding
+      xmlattr :group_id,          :xpath => %Q{apps:property[@name = "groupId"]/@value}
+      xmlattr :group_name,        :xpath => %Q{apps:property[@name = "groupName"]/@value}
+      xmlattr :email_permission,  :xpath => %Q{apps:property[@name = "emailPermission"]/@value}
+      xmlattr :permission_preset, :xpath => %Q{apps:property[@name = "permissionPreset"]/@value}
+      xmlattr :description,       :xpath => %Q{apps:property[@name = "description"]/@value}
+
+      # Retrieves all users within a domain
+      def self.all(connection, options={})
+
+        # TODO Fail if unrecognized options passed
+        url = "/group/2.0/:domain"
+        if member = options[:member]
+          url << "/?member=#{member}"
+
+          if direct_only = options[:direct_only]
+            url << "&directOnly=#{direct_only}"
+          end
+        end
+
+        feed = GProv::Provision::Feed.new(connection, url, "/xmlns:feed/xmlns:entry")
+        entries = feed.fetch
+        entries.map { |xml| new(:status => :clean, :connection => connection, :source => xml) }
+      end
+
+      def self.get(connection, group_id)
+        response = connection.get("/group/2.0/:domain/#{group_id}")
+        document = Nokogiri::XML(response.body)
+        xml = document.root
+
+        new(:status => :clean, :connection => connection, :source => xml)
+      end
+
+      def to_nokogiri
+        base_document = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml.entry('xmlns:atom' => 'http://www.w3.org/2005/Atom',
+                    'xmlns:apps' => 'http://schemas.google.com/apps/2006',
+                    'xmlns:gd'   => "http://schemas.google.com/g/2005" ) {
+
+            # Namespaces cannot be used until they are declared, so we need to
+            # retroactively declare the namespace of the parent
+            xml.parent.namespace = xml.parent.namespace_definitions.select {|ns| ns.prefix == "atom"}.first
+            xml.category("scheme" => "http://schemas.google.com/g/2005#kind",
+                         "term"   =>"http://schemas.google.com/apps/2006#user")
+
+            xml['apps'].property("name" => "groupId",         "value" => @group_id)
+            xml['apps'].property("name" => "groupName",       "value" => @group_name)
+            xml['apps'].property("name" => "emailPermission", "value" => @email_permission)
+            xml['apps'].property("name" => "description",     "value" => @description)
+          }
+        end
+
+        base_document
+      end
+
+      def create!
+        response = connection.post("/group/2.0/:domain", {:body => to_nokogiri.to_xml})
+        status = :clean
+      end
+
+      def update!
+        response = connection.put("/group/2.0/:domain", {:body => to_nokogiri.to_xml})
+        status = :clean
+      end
+
+      def delete!
+        response = connection.put("/group/2.0/:domain/#{group_id}")
+        status = :deleted
+      end
+
+      def add_member(membername)
+        member = GProv::Provision::Member.new(
+          :connection => @connection,
+          :source => {
+            :group_id => @group_id,
+            :member_id => membername,
+          }
+        )
+        member.create!
+      end
+
+      def del_member(membername)
+        member = GProv::Provision::Member.new(
+          :connection => @connection,
+          :source => {
+            :group_id => @group_id,
+            :member_id => membername,
+          }
+        )
+        member.delete!
+      end
+
+      def list_members
+        GProv::Provision::Member.all(@connection, @group_id)
+      end
+
+      def add_owner(ownername)
+        owner = GProv::Provision::Owner.new(
+          :connection => @connection,
+          :source => {
+            :group_id => @group_id,
+            :email => ownername,
+          }
+        )
+        owner.create!
+      end
+
+      def del_owner(ownername)
+        owner = GProv::Provision::Owner.new(
+          :connection => @connection,
+          :source => {
+            :group_id => @group_id,
+            :email => ownername,
+          }
+        )
+        owner.delete!
+      end
+
+      def list_owners
+        GProv::Provision::Owner.all(@connection, @group_id)
+      end
+    end
+  end
+end

data/lib/gprov/provision/member.rb

@@ -0,0 +1,48 @@
+# Representation of group members
+require 'gprov'
+require 'gprov/provision/entrybase'
+
+module GProv
+  module Provision
+    class Member < GProv::Provision::EntryBase
+
+      xmlattr :member_id,     :xpath => %Q{apps:property[@name = "memberId"]/@value}
+      xmlattr :member_type,   :xpath => %Q{apps:property[@name = "memberType"]/@value}
+      xmlattr :direct_member, :xpath => %Q{apps:property[@name = "directMember"]/@value}
+      attr_accessor :group_id
+
+      def self.all(connection, group_id)
+        feed = GProv::Provision::Feed.new(connection, "/group/2.0/:domain/#{group_id}/member", "/xmlns:feed/xmlns:entry")
+        entries = feed.fetch
+        entries.map { |xml| new(:status => :clean, :connection => connection, :source => xml) }
+      end
+      
+      def to_nokogiri
+        base_document = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml.entry('xmlns:atom' => 'http://www.w3.org/2005/Atom',
+                    'xmlns:apps' => 'http://schemas.google.com/apps/2006',
+                    'xmlns:gd'   => "http://schemas.google.com/g/2005" ) {
+
+            # Namespaces cannot be used until they are declared, so we need to
+            # retroactively declare the namespace of the parent
+            xml.parent.namespace = xml.parent.namespace_definitions.select {|ns| ns.prefix == "atom"}.first
+
+            xml['apps'].property("name" => "memberId", "value" => @member_id)
+          }
+        end
+
+        base_document
+      end
+
+      def create!
+        response = connection.post("/group/2.0/:domain/#{@group_id}/member", {:body => to_nokogiri.to_xml})
+        status = :clean
+      end
+
+      def delete!
+        response = connection.delete("/group/2.0/:domain/#{@group_id}/member/#{@member_id}")
+        status = :clean
+      end
+    end
+  end
+end

data/lib/gprov/provision/orgmember.rb

@@ -0,0 +1,84 @@
+# = gprov/provision/orgmember.rb
+#
+# == Overview
+#
+# Representation of the members of organizational units
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'gprov'
+require 'gprov/provision/feed'
+require 'gprov/provision/entrybase'
+module GProv
+  module Provision
+    class OrgMember < GProv::Provision::EntryBase
+
+      # This attribute will only be received and never sent
+      xmlattr :org_user_email, :xpath => %Q{apps:property[@name = "orgUserEmail"]/@value}
+      xmlattr :org_unit_path,  :xpath => %Q{apps:property[@name = "orgUnitPath"]/@value}
+
+      # Retrieve all organization users in the domain.
+      def self.all(connection, options = {:target => :all})
+        id = GProv::Provision::CustomerID.get(connection)
+
+        case options[:target]
+        when :orgunit
+          # XXX validation
+          url = "/orguser/2.0/#{id.customer_id}?get=children&orgUnitPath=#{options[:orgunit]}"
+        when :all
+          url = "/orguser/2.0/#{id.customer_id}?get=all"
+        end
+
+        feed = GProv::Provision::Feed.new(connection, url, "/xmlns:feed/xmlns:entry")
+        entries = feed.fetch
+        entries.map { |xml| new(:status => :clean, :connection => connection, :source => xml) }
+      end
+
+      def self.get(connection, email)
+        id = GProv::Provision::CustomerID.get(connection)
+        response = connection.get("/orguser/2.0/#{id.customer_id}/#{email}")
+
+        document = Nokogiri::XML(response.body)
+        xml = document.root
+
+        new(:status => :clean, :connection => connection, :source => xml)
+      end
+
+      # This attribute will only be sent and never received
+      def initialize(opts={})
+        super
+        # Generate this variable in the case that the org_unit_path is updated
+        @old_org_unit_path = @org_unit_path
+      end
+
+      def to_nokogiri
+        base_document = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml.entry('xmlns:atom' => 'http://www.w3.org/2005/Atom',
+                    'xmlns:apps' => 'http://schemas.google.com/apps/2006',
+                    'xmlns:gd'   => "http://schemas.google.com/g/2005" ) {
+
+            # Namespaces cannot be used until they are declared, so we need to
+            # retroactively declare the namespace of the parent
+            xml.parent.namespace = xml.parent.namespace_definitions.select {|ns| ns.prefix == "atom"}.first
+
+            xml['apps'].property("name" => "orgUnitPath", "value" => @org_unit_path)
+            xml['apps'].property("name" => "oldOrgUnitPath", "value" => @old_org_unit_path)
+          }
+        end
+      end
+
+      def update!
+        id = GProv::Provision::CustomerID.get(connection)
+        response = connection.put("/orguser/2.0/#{id.customer_id}/#{@org_user_email}", {:body => to_nokogiri.to_xml})
+        status = :clean
+      end
+    end
+  end
+end
+

data/lib/gprov/provision/orgunit.rb

@@ -0,0 +1,89 @@
+# = gprov/provision/orgunit.rb
+#
+# == Overview
+#
+# implementation of the gprov organizational unit
+#
+# == Authors
+#
+# Adrien Thebo
+#
+# == Copyright
+#
+# 2011 Puppet Labs
+#
+require 'gprov'
+require 'gprov/provision/feed'
+require 'gprov/provision/entrybase'
+require 'gprov/provision/customerid'
+require 'gprov/provision/orgmember'
+module GProv
+  module Provision
+    class OrgUnit < GProv::Provision::EntryBase
+
+      xmlattr :name,                 :xpath => %Q{apps:property[@name = "name"]/@value}
+      xmlattr :description,          :xpath => %Q{apps:property[@name = "description"]/@value}
+      xmlattr :org_unit_path,        :xpath => %Q{apps:property[@name = "orgUnitPath"]/@value}
+      xmlattr :parent_org_unit_path, :xpath => %Q{apps:property[@name = "parentOrgUnitPath"]/@value}
+      xmlattr :block_inheritance,    :xpath => %Q{apps:property[@name = "blockInheritance"]/@value}
+
+      def self.all(connection)
+        id = GProv::Provision::CustomerID.get(connection)
+        feed = GProv::Provision::Feed.new(connection, "/orgunit/2.0/#{id.customer_id}?get=all", "/xmlns:feed/xmlns:entry")
+        entries = feed.fetch
+        entries.map { |xml| new(:status => :clean, :connection => connection, :source => xml) }
+      end
+
+      def self.get(connection, org_path)
+        id = GProv::Provision::CustomerID.get(connection)
+        response = connection.get("/orgunit/2.0/#{id.customer_id}/#{org_path}")
+        document = Nokogiri::XML(response.body)
+        xml = document.root
+
+        new(:status => :clean, :connection => connection, :source => xml)
+      end
+
+      def to_nokogiri
+        base_document = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml.entry('xmlns:atom' => 'http://www.w3.org/2005/Atom',
+                    'xmlns:apps' => 'http://schemas.google.com/apps/2006',
+                    'xmlns:gd'   => "http://schemas.google.com/g/2005" ) {
+
+            # Namespaces cannot be used until they are declared, so we need to
+            # retroactively declare the namespace of the parent
+            xml.parent.namespace = xml.parent.namespace_definitions.select {|ns| ns.prefix == "atom"}.first
+
+            xml['apps'].property("name" => "name", "value" => @name)
+            xml['apps'].property("name" => "description", "value" => @description)
+            xml['apps'].property("name" => "parentOrgUnitPath", "value" => @parent_org_unit_path)
+            xml['apps'].property("name" => "blockInheritance", "value" => @block_inheritance)
+          }
+        end
+      end
+
+      def create!
+        # xxx cache this?
+        id = GProv::Provision::CustomerID.get(connection)
+        response = connection.post("/orgunit/2.0/#{id.customer_id}")
+        status = :clean
+      end
+
+      def update!
+        # xxx cache this?
+        id = GProv::Provision::Customerid.get(connection)
+        response = connection.put("/orgunit/2.0/#{id.customer_id}/#{@org_unit_path}")
+        status = :clean
+      end
+
+      def delete!
+        id = GProv::Provision::Customerid.get(connection)
+        response = connection.delete("/orgunit/2.0/#{id.customer_id}/#{@org_unit_path}")
+        status = :deleted
+      end
+
+      def list_members
+        GProv::Provision::OrgMember.all(connection, :target => :orgunit, :orgunit => @org_unit_path)
+      end
+    end
+  end
+end

data/lib/gprov/provision/owner.rb

@@ -0,0 +1,46 @@
+# Representation of group owners
+require 'gprov'
+require 'gprov/provision/entrybase'
+
+module GProv
+  module Provision
+    class Owner < GProv::Provision::EntryBase
+
+      xmlattr :email, :xpath => %Q{apps:property[@name = "email"]/@value}
+      attr_accessor :group_id
+
+      def self.all(connection, group_id)
+        feed = GProv::Provision::Feed.new(connection, "/group/2.0/:domain/#{group_id}/owner", "/xmlns:feed/xmlns:entry")
+        entries = feed.fetch
+        entries.map { |xml| new(:status => :clean, :connection => connection, :source => xml) }
+      end
+
+      def to_nokogiri
+        base_document = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml.entry('xmlns:atom' => 'http://www.w3.org/2005/Atom',
+                    'xmlns:apps' => 'http://schemas.google.com/apps/2006',
+                    'xmlns:gd'   => "http://schemas.google.com/g/2005" ) {
+
+            # Namespaces cannot be used until they are declared, so we need to
+            # retroactively declare the namespace of the parent
+            xml.parent.namespace = xml.parent.namespace_definitions.select {|ns| ns.prefix == "atom"}.first
+
+            xml['apps'].property("name" => "email", "value" => @email)
+          }
+        end
+
+        base_document
+      end
+
+      def create!
+        response = connection.post("/group/2.0/:domain/#{@group_id}/owner", {:body => to_nokogiri.to_xml})
+        status = :clean
+      end
+
+      def delete!
+        response = connection.delete("/group/2.0/:domain/#{@group_id}/owner/#{@email}")
+        status = :clean
+      end
+    end
+  end
+end