gtool 0.0.1

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,99 @@
+Gtool
+=====
+
+Interact with the Google Provisioning API from the command line.
+
+Description
+-----------
+
+Gtool provides a command line interface for inspecting and interacting with
+the Google Apps Provisioning API. You can create, view, edit and remove
+pretty much any entity available.
+
+Installation
+------------
+
+**as a gem**
+
+Wait for someone to turn this into a gem.
+
+**from source**
+
+    git clone git://github.com/adrienthebo/ruby-gprov
+    git clone git://github.com/adrienthebo/gtool
+
+    export RUBYLIB="${RUBYLIB}:`pwd`/ruby-gprov/lib:`pwd`/gtool/lib"
+    export PATH="${PATH}:`pwd`/gtool/bin"
+
+    % gtool # magic!
+
+Usage
+-----
+
+**General Usage**
+
+    % gtool
+    Tasks:
+      gtool auth [COMMAND]     # GProv authentication operations
+      gtool customerid         # Display Customer ID for the domain
+      gtool group [COMMAND]    # GProv group provisioning
+      gtool help [TASK]        # Describe available tasks or one specific task
+      gtool orgunit [COMMAND]  # GProv user provisioning
+      gtool user [COMMAND]     # GProv user provisioning
+
+- - -
+
+**Authentication**
+
+    % gtool auth
+    Tasks:
+      gtool auth display         # Displays the cached credentials
+      gtool auth generate        # Generate a token using the clientlogin method
+
+    % gtool auth generate
+    Username: user@example.com
+    Password:
+    Service (defaults to apps):
+    Domain: example.com
+    Authentication accepted, token valid till Sun Dec 04 22:32:29 -0800 2011
+
+    % gtool auth display
+    created: Sat Dec 03 22:32:29 -0800 2011 (valid)
+    token: API_TOKEN_HERE
+
+- - -
+
+**Users**
+
+    % gtool user
+    Tasks:
+      gtool user create USER     # Create a new user
+      gtool user delete USER     # Delete a user
+      gtool user get USER        # Get a user
+      gtool user list            # List users
+
+- - -
+
+**Groups**
+
+    % gtool group
+    Tasks:
+      gtool group addmember GROUP MEMBER  # Add a member to a group
+      gtool group delmember GROUP MEMBER  # Remove a member from a group
+      gtool group get GROUP               # Get a particular group instance
+      gtool group list                    # List groups
+      gtool group members GROUP           # Display members of a group
+
+
+
+**Organizational Units**
+
+    % gtool orgunit
+    Tasks:
+      gtool orgunit get ORGUNIT      # Get an orgunit
+      gtool orgunit list             # List organizational units
+      gtool orgunit members ORGUNIT  # Get the members of an orgunit
+
+- - -
+
+More complete documentation is pending on a more complete codebase.

data/Rakefile

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

data/bin/gtool

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require 'gtool'
+require 'gprov/error'
+require 'thor/shell/color'
+begin
+  Gtool::CLI.start
+rescue GData::Error::TokenInvalid
+  Thor::Shell::Color.new.say "Invalid token, run '#{$0} auth generate' to generate a valid token.", :red
+rescue GData::Error::QuotaExceeded
+  Thor::Shell::Color.new.say "API quota exceeded, try again later.", :red
+rescue GData::Error::InputInvalid => e
+  Thor::Shell::Color.new.say "Request failed; sent invalid input", :red
+  $stderr.puts e.request.inspect
+rescue GData::Error => e
+  $stderr.puts "Generic GData API error occurred"
+  $stderr.puts e.request.inspect
+rescue Interrupt
+  $stderr.puts "\nAborted!"
+end

data/lib/gtool.rb

@@ -0,0 +1,17 @@
+begin
+  require 'thor'
+  require 'thor/group'
+rescue LoadError
+  require 'rubygems'
+  require 'thor'
+  require 'thor/group'
+end
+
+require 'gtool/version'
+require 'gtool/cli'
+require 'gtool/auth'
+require 'gtool/provision/user'
+require 'gtool/provision/group'
+require 'gtool/provision/customerid'
+require 'gtool/provision/orgunit'
+require 'gtool/provision/orgmember'

data/lib/gtool/auth.rb

@@ -0,0 +1,81 @@
+require 'gtool'
+require 'gtool/util/ask_default'
+require 'gprov'
+require 'yaml'
+
+module Gtool
+  class Auth < Thor
+    include Gtool::Util
+    Gtool::CLI.register self, "auth", "auth [COMMAND]", "GProv authentication operations"
+    namespace :auth
+
+    TOKEN_DURATION = 60 * 60 * 24 * 14
+
+    desc "generate", "Generate a token using the clientlogin method"
+    method_option "debug", :type => :boolean, :desc => "Enable debug output", :aliases => "-d"
+    method_option "noop",  :type => :boolean, :desc => "Enable noop mode", :aliases => "-n"
+    def generate
+      user = ask "Username:"
+      %x{stty -echo}
+      pass = ask "Password:"
+      %x{stty echo}
+      puts
+
+      service = ask_default "apps", "Service (defaults to apps):"
+
+      domain  = ask "Domain:"
+
+      authject = GProv::Auth::ClientLogin.new(user, pass, service, options)
+      token = authject.token
+
+      if token.nil?
+        say "Authentication failed!", :red
+      else
+        say "Authentication accepted, token valid till #{Time.now + TOKEN_DURATION}", :green
+        credentials = {:token => token, :created => Time.now, :domain => domain}
+
+        File.open("#{ENV['HOME']}/.gtool.yaml", "w") do |f|
+          f.write(YAML.dump(credentials))
+          f.chmod 0600
+        end
+      end
+    end
+
+    desc "display", "Displays the cached credentials"
+    def display
+      settings = self.class.settings
+
+      expiration = Time.at(settings[:created]) + TOKEN_DURATION
+
+      if Time.now > expiration
+        say "created: #{settings[:created]} (expired)", :red
+      else
+        say "created: #{settings[:created]} (valid)", :green
+        say "expires: #{expiration}", :green
+      end
+      say "token: #{settings[:token]}", :cyan
+    end
+
+    def self.settings
+      settings = nil
+      creds_file = "#{ENV['HOME']}/.gtool.yaml"
+      begin
+        File.open creds_file do |f|
+          settings = YAML::load f.read
+        end
+      rescue Errno::ENOENT
+        puts "#{creds_file} does not exist, run 'gtool auth generate'"
+        exit
+      end
+      settings
+    end
+
+    def self.connection(options)
+      connection = GProv::Connection.new(settings[:domain], settings[:token], options)
+    end
+
+    def self.banner(task, namespace = true, subcommand = false)
+      "#{basename} #{task.formatted_usage(self, true, subcommand)}"
+    end
+  end
+end

data/lib/gtool/cli.rb

@@ -0,0 +1,5 @@
+
+module Gtool
+  class CLI < Thor
+  end
+end

data/lib/gtool/provision/customerid.rb

@@ -0,0 +1,25 @@
+require 'thor'
+require 'thor/group'
+require 'gtool'
+require 'gprov'
+
+module Gtool
+  module Provision
+    class CustomerID < Thor::Group
+      Gtool::CLI.register self, "customerid", "customerid", "Display Customer ID for the domain"
+
+      class_option "debug", :type => :boolean, :default => false, :desc => "Enable debug output", :aliases => "-d"
+      class_option "noop",  :type => :boolean, :default => false, :desc => "Enable noop mode", :aliases => "-n"
+
+      def display
+        connection = Gtool::Auth.connection(options)
+        fields = GProv::Provision::CustomerID.attribute_names
+        field_names = GProv::Provision::CustomerID.attribute_titles
+        id = GProv::Provision::CustomerID.get(connection)
+
+        properties = fields.map {|f| id.send f}
+        print_table field_names.zip(properties)
+      end
+    end
+  end
+end

data/lib/gtool/provision/group.rb

@@ -0,0 +1,172 @@
+require 'thor'
+require 'gtool'
+require 'gtool/util/ask_default'
+require 'gprov'
+
+module Gtool
+  module Provision
+    class Group < Thor
+      include Gtool::Util
+      Gtool::CLI.register self, "group", "group [COMMAND]", "GProv group provisioning"
+      namespace :group
+
+      class_option "debug", :type => :boolean, :default => false, :desc => "Enable debug output", :aliases => "-d"
+      class_option "noop",  :type => :boolean, :default => false, :desc => "Enable noop mode", :aliases => "-n"
+
+      desc "list", "List groups"
+      def list
+        connection = Gtool::Auth.connection(options)
+        groups = GProv::Provision::Group.all(connection)
+        fields = GProv::Provision::Group.attribute_names
+        field_names = GProv::Provision::Group.attribute_titles
+
+        rows = groups.map do |group|
+          fields.map {|f| group.send f}
+        end
+
+        rows.unshift field_names
+        print_table rows
+        say "#{rows.length - 1} entries.", :cyan
+      end
+
+      desc "get GROUP", "Get a particular group instance"
+      def get(groupname)
+        connection = Gtool::Auth.connection(options)
+        group = GProv::Provision::Group.get(connection, groupname)
+        fields = GProv::Provision::Group.attribute_names
+        field_names = GProv::Provision::Group.attribute_titles
+
+        if group.nil?
+          say "Group '#{groupname}' not found!", :red
+        else
+          properties = fields.map {|f| group.send f}
+          print_table field_names.zip(properties)
+        end
+      end
+
+      desc "create GROUP", "Create a new group"
+      def create(groupname)
+        connection = Gtool::Auth.connection(options)
+        group = GProv::Provision::Group.new(:connection => connection)
+
+        group.group_id = groupname
+        group.group_name        = ask "Group name:"
+        group.email_permission  = ask "Email Permission:"
+        group.permission_preset = ask "Permission Preset:"
+        group.description       = ask "Group Description:"
+
+        group.create!
+
+        invoke "group:get", [group.group_id]
+      end
+
+      # TODO update group This is pending on the the backing group being able
+      # to store the group_id for the case that the group_id here is changed,
+      # but needs to post back to a specific url
+
+      desc "members GROUP", "Display members of a group"
+      def members(groupname)
+        connection = Gtool::Auth.connection(options)
+        group = GProv::Provision::Group.get(connection, groupname)
+        fields = GProv::Provision::Member.attribute_names
+        field_names = GProv::Provision::Member.attribute_titles
+
+        if group.nil?
+          say "Group '#{groupname}' not found!", :red
+        else
+          members = group.list_members
+
+          rows = members.map do |member|
+            fields.map {|f| member.send f}
+          end
+
+          rows.unshift field_names
+          print_table rows
+        say "#{rows.length - 1} entries.", :cyan
+        end
+      end
+
+      desc "addmember GROUP MEMBER", "Add a member to a group"
+      def addmember(groupname, member)
+        connection = Gtool::Auth.connection(options)
+        group = GProv::Provision::Group.get(connection, groupname)
+
+        if group.nil?
+          say "Group '#{groupname}' not found!", :red
+        else
+          group.add_member member
+          invoke "group:members", [groupname]
+        end
+      end
+
+      desc "delmember GROUP MEMBER", "Remove a member from a group"
+      def delmember(groupname, member)
+        connection = Gtool::Auth.connection(options)
+        group = GProv::Provision::Group.get(connection, groupname)
+
+        if group.nil?
+          say "Group '#{groupname}' not found!", :red
+        else
+          group.del_member member
+          invoke "group:members", [groupname]
+        end
+      end
+
+      desc "owners GROUP", "Display owners of a group"
+      def owners(groupname)
+        connection = Gtool::Auth.connection(options)
+        group = GProv::Provision::Group.get(connection, groupname)
+        fields = GProv::Provision::Owner.attribute_names
+        field_names = GProv::Provision::Owner.attribute_titles
+
+        if group.nil?
+          say "Group '#{groupname}' not found!", :red
+        else
+          owners = group.list_owners
+
+          if owners.nil?
+            say "Group #{groupname} has no owners!", :red
+          else
+            rows = owners.map { |owner| fields.map {|f| owner.send f} }
+
+            rows.unshift field_names
+            # XXX https://github.com/wycats/thor/issues/100
+            # print_table rows
+            puts rows.join("\n")
+            say "#{rows.length - 1} entries.", :cyan
+          end
+        end
+      end
+
+      desc "addowner GROUP OWNER", "Add an owner to a group"
+      def addowner(groupname, owner)
+        connection = Gtool::Auth.connection(options)
+        group = GProv::Provision::Group.get(connection, groupname)
+
+        if group.nil?
+          say "Group '#{groupname}' not found!", :red
+        else
+          group.add_owner owner
+          invoke "group:owners", [groupname]
+        end
+      end
+
+      desc "delowner GROUP OWNER", "Remove an owner from a group"
+      def delowner(groupname, owner)
+        connection = Gtool::Auth.connection(options)
+        group = GProv::Provision::Group.get(connection, groupname)
+
+        if group.nil?
+          say "Group '#{groupname}' not found!", :red
+        else
+          group.del_owner owner
+          invoke "group:owners", [groupname]
+        end
+      end
+
+      def self.banner(task, namespace = true, subcommand = false)
+        "#{basename} #{task.formatted_usage(self, true, subcommand)}"
+      end
+    end
+  end
+end

data/lib/gtool/provision/orgmember.rb

@@ -0,0 +1,67 @@
+require 'thor'
+require 'gtool'
+require 'gprov'
+
+module Gtool
+  module Provision
+    class OrgMember < Thor
+      Gtool::CLI.register self, "orgmember", "orgmember [COMMAND]", "GProv organizational member provisioning"
+      namespace :orgmember
+
+      class_option "debug", :type => :boolean, :desc => "Enable debug output", :aliases => "-d"
+      class_option "noop",  :type => :boolean, :desc => "Enable noop mode", :aliases => "-n"
+
+      desc "list", "Get the members of an orgunit"
+      method_option "orgunit", :type => :string, :desc => "The orgunit from which to retrive users"
+      def list
+        if options[:orgunit]
+          options_hash = {:target => :orgunit, :orgunit => options[:orgunit]}
+        else
+          options_hash = {:target => :all}
+        end
+
+        connection = Gtool::Auth.connection(options)
+        orgmembers = GProv::Provision::OrgMember.all(connection, options_hash)
+        fields = GProv::Provision::OrgMember.attribute_names
+        field_names = GProv::Provision::OrgMember.attribute_titles
+
+        rows = orgmembers.map do |member|
+          fields.map {|f| member.send f}
+        end
+
+        rows.unshift field_names
+        print_table rows
+        say "#{rows.length - 1} entries.", :cyan
+      end
+
+      desc "get MEMBER", "Retrieve a specific orgunit member"
+      def get(membername)
+        connection = Gtool::Auth.connection(options)
+        orgmember = GProv::Provision::OrgMember.get(connection, membername)
+        fields = GProv::Provision::OrgMember.attribute_names
+        field_names = GProv::Provision::OrgUnit.attribute_titles
+
+        if orgmember.nil?
+          say "Organizational unit '#{orgmember}' not found!", :red
+        else
+          properties = fields.map {|f| orgmember.send f}
+          print_table field_names.zip(properties)
+        end
+      end
+
+      desc "move ORG_MEMBER, NEW_ORGUNIT", "Move an organization unit member"
+      def move(membername, orgunit)
+        connection = Gtool::Auth.connection(options)
+        orgmember = GProv::Provision::OrgMember.get(connection, membername)
+        orgmember.org_unit_path = orgunit
+        orgmember.update!
+
+        invoke "orgmember:get", [membername]
+      end
+
+      def self.banner(task, namespace = true, subcommand = false)
+        "#{basename} #{task.formatted_usage(self, true, subcommand)}"
+      end
+    end
+  end
+end

data/lib/gtool/provision/orgunit.rb

@@ -0,0 +1,50 @@
+require 'thor'
+require 'gtool'
+require 'gprov'
+
+module Gtool
+  module Provision
+    class OrgUnit < Thor
+      Gtool::CLI.register self, "orgunit", "orgunit [COMMAND]", "GProv organizational unit provisioning"
+      namespace :orgunit
+
+      class_option "debug", :type => :boolean, :desc => "Enable debug output", :aliases => "-d"
+      class_option "noop",  :type => :boolean, :desc => "Enable noop mode", :aliases => "-n"
+
+      desc "list", "List organizational units"
+      def list
+        connection = Gtool::Auth.connection(options)
+        orgunits = GProv::Provision::OrgUnit.all(connection)
+        fields = GProv::Provision::OrgUnit.attribute_names
+        field_names = GProv::Provision::OrgUnit.attribute_titles
+
+        rows = orgunits.map do |orgunit|
+          fields.map {|f| orgunit.send f}
+        end
+
+        rows.unshift field_names
+        print_table rows
+        say "#{rows.length - 1} entries.", :cyan
+      end
+
+      desc "get ORGUNIT", "Get an orgunit"
+      def get(orgunit_name)
+        connection = Gtool::Auth.connection(options)
+        orgunit = GProv::Provision::OrgUnit.get(connection, orgunit_name)
+        fields = GProv::Provision::OrgUnit.attribute_names
+        field_names = GProv::Provision::OrgUnit.attribute_titles
+
+        if orgunit.nil?
+          say "Organizational unit '#{orgunit_name}' not found!", :red
+        else
+          properties = fields.map {|f| orgunit.send f}
+          print_table field_names.zip(properties)
+        end
+      end
+
+      def self.banner(task, namespace = true, subcommand = false)
+        "#{basename} #{task.formatted_usage(self, true, subcommand)}"
+      end
+    end
+  end
+end

data/lib/gtool/provision/user.rb

@@ -0,0 +1,128 @@
+require 'thor'
+require 'gtool'
+require 'gtool/util/ask_default'
+require 'gprov'
+require 'digest/sha1'
+
+module Gtool
+  module Provision
+    class User < Thor
+      include Gtool::Util
+      Gtool::CLI.register self, "user", "user [COMMAND]", "GProv user provisioning"
+      namespace :user
+
+      class_option "debug", :type => :boolean, :desc => "Enable debug output", :aliases => "-d"
+      class_option "noop",  :type => :boolean, :desc => "Enable noop mode", :aliases => "-n"
+
+      desc "list", "List users"
+      def list
+        connection = Gtool::Auth.connection(options)
+        users = GProv::Provision::User.all(connection)
+        fields = GProv::Provision::User.attribute_names
+        field_names = GProv::Provision::User.attribute_titles
+
+        rows = users.map do |user|
+          fields.map {|f| user.send f}
+        end
+
+        rows.unshift field_names
+        print_table rows
+        say "#{rows.length - 1} entries.", :cyan
+      end
+
+      desc "get USER", "Get a user"
+      def get(username)
+        connection = Gtool::Auth.connection(options)
+        user = GProv::Provision::User.get(connection, username)
+        fields = GProv::Provision::User.attribute_names
+        field_names = GProv::Provision::User.attribute_titles
+
+        if user.nil?
+          say "User '#{username}' not found!", :red
+        else
+          properties = fields.map {|f| user.send f}
+          print_table field_names.zip(properties)
+        end
+      end
+
+      desc "create USER", "Create a new user"
+      def create(username)
+        connection = Gtool::Auth.connection(options)
+
+        user = GProv::Provision::User.new(:connection => connection)
+
+        user.user_name   = username
+        user.given_name  = ask "Given Name:"
+        user.family_name = ask "Family Name:"
+
+        # password! wheee!
+        %x{stty -echo}
+        user.password = Digest::SHA1.hexdigest(ask "Password:")
+        user.hash_function_name = "SHA-1"
+        %x{stty echo}
+
+        user.create!
+
+        invoke "user:get", [user.user_name]
+      end
+
+      desc "update USER", "Update an existing user"
+      def update(username)
+        connection = Gtool::Auth.connection(options)
+
+        user = GProv::Provision::User.get(connection, username)
+
+        user.user_name       = ask_default(user.user_name,       "Username (#{user.user_name}):")
+        user.given_name      = ask_default(user.given_name,      "Given Name (#{user.given_name}):")
+        user.family_name     = ask_default(user.family_name,     "Family Name (#{user.family_name}):")
+        user.admin           = ask_default(user.admin,           "Administrator (#{user.admin}):")
+        user.agreed_to_terms = ask_default(user.agreed_to_terms, "Agreed to terms (#{user.agreed_to_terms}):")
+        user.suspended       = ask_default(user.suspended,       "Suspended (#{user.suspended}):")
+        user.change_password_at_next_login = ask_default(user.change_password_at_next_login, "Change password at next login (#{user.change_password_at_next_login}):")
+
+        %x{stty -echo}
+        password = ask "Password (blank will not change):"
+        unless password.empty?
+          user.password = Digest::SHA1.hexdigest(password)
+          user.hash_function_name = "SHA-1"
+        end
+        %x{stty echo}
+
+        user.update!
+
+        invoke "user:get", [user.user_name]
+      end
+
+      desc "delete USER", "Delete a user"
+      def delete(username)
+        connection = Gtool::Auth.connection(options)
+        invoke "user:get", [username]
+        user = GProv::Provision::User.get(connection, username)
+
+        if user and (yes? "Permanently delete this user?") and (username == ask("Type in #{username} to confirm:"))
+          user.delete!
+        end
+      end
+
+      desc "groups USER", "Retrieve groups for a user"
+      def groups(username)
+        connection = Gtool::Auth.connection(options)
+        groups = GProv::Provision::Group.all(connection, :member => username)
+        fields = GProv::Provision::Group.attribute_names
+        field_names = GProv::Provision::Group.attribute_titles
+
+        rows = groups.map do |group|
+          fields.map {|f| group.send f}
+        end
+
+        rows.unshift field_names
+        print_table rows
+        say "#{rows.length - 1} entries.", :cyan
+      end
+
+      def self.banner(task, namespace = true, subcommand = false)
+        "#{basename} #{task.formatted_usage(self, true, subcommand)}"
+      end
+    end
+  end
+end

data/lib/gtool/util/ask_default.rb

@@ -0,0 +1,10 @@
+
+module Gtool
+  module Util
+    def ask_default(default, statement, color=nil)
+      result = ask statement, color
+      result = default if result.empty?
+      result
+    end
+  end
+end

data/lib/gtool/version.rb

@@ -0,0 +1,4 @@
+
+module Gtool
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: gtool
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Adrien Thebo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-02 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: gprov
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 0
+        - 2
+        version: 0.0.2
+  type: :runtime
+  version_requirements: *id001
+description: All the fun of Google Provisioning, none of the HTML
+email: adrien@puppetlabs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/gtool
+- lib/gtool/auth.rb
+- lib/gtool/cli.rb
+- lib/gtool/provision/customerid.rb
+- lib/gtool/provision/group.rb
+- lib/gtool/provision/orgmember.rb
+- lib/gtool/provision/orgunit.rb
+- lib/gtool/provision/user.rb
+- lib/gtool/util/ask_default.rb
+- lib/gtool/version.rb
+- lib/gtool.rb
+- LICENSE
+- Rakefile
+- README.markdown
+homepage: http://github.com/adrienthebo/gtool
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Command line interface to the Google Provisioning API
+test_files: []
+