sfrest 0.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7045fc0312fa3b50c38c0605a27b900a9a50a08e
+  data.tar.gz: 8f31a1b7ecc1e6d1bb13a47e36d7fc20c05bbdc4
+SHA512:
+  metadata.gz: c1273edd11d4687be24897f2d76e7210abde28982f8377fcc54acf909af4f7890abedbc9aba15cb4b5c4f9453886243d5bdee90ac0a404d5ed3089ba1e16ae50
+  data.tar.gz: 5021fe6693f4af1bd6624cf9956c9568b5373e24a5bbe61ee483bdde5c08c8ec982f9dcfee990d934ea6699407516bc56fe3d79026c99299ac98cdb414dec06a

data/lib/sfrest/audit.rb

@@ -0,0 +1,16 @@
+module SFRest
+  # Get all the audit devents.
+  class Audit
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # Lists audit events.
+    # @return [Hash{'count' => Integer, 'changes' => [Hash, Hash]}]
+    def list_audit_events
+      current_path = '/api/v1/audit'
+      @conn.get(current_path)
+    end
+  end
+end

data/lib/sfrest/backup.rb

@@ -0,0 +1,46 @@
+module SFRest
+  # Backup a site or restore onto that site
+  class Backup
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # cool stuff goes here
+    # @param [Integer] site_id the node id of the site node
+    # @return [Hash]
+    def get_backups(site_id, datum = nil)
+      current_path = "/api/v1/sites/#{site_id}/backups"
+      pb = SFRest::Pathbuilder.new
+      @conn.get URI.parse(URI.encode(pb.build_url_query(current_path, datum))).to_s
+    end
+
+    # Deletes a site backup.
+    # @param [Integer] site_id Node id of site
+    # @param [Integer] backup_id Id of backup to delete
+    def delete_backup(site_id, backup_id)
+      current_path = "/api/v1/sites/#{site_id}/backups/#{backup_id}"
+      @conn.delete(current_path)
+    end
+
+    # Backs up a site.
+    # @param [Integer] site_id
+    # @param [Hash] datum Options to the backup
+    # @option datum [String] 'label'
+    # @option datum [Url] 'callback_url'
+    # @option datum [String] 'callback_method' GET|POST
+    # @option datum [Json] 'caller_data' json encoded string
+    def create_backup(site_id, datum = nil)
+      current_path = "/api/v1/sites/#{site_id}/backup"
+      @conn.post(current_path, datum.to_json)
+    end
+
+    # Gets a url to download a backup
+    # @param [Integer] site_id Node id of site
+    # @param [Integer] backup_id Id of backup to delete
+    # @param [Integer] lifetime TTL of the url
+    def backup_url(site_id, backup_id, lifetime = 60)
+      @conn.get("/api/v1/sites/#{site_id}/backups/#{backup_id}/url?lifetime=#{lifetime}")
+    end
+  end
+end

data/lib/sfrest/connection.rb

@@ -0,0 +1,173 @@
+module SFRest
+  # Generic http methods
+  # accessors for all the sub classes.
+  class Connection
+    attr_accessor :base_url, :username, :password
+
+    # @param [String] url base url of the SF endpoint e.g. https://www.sfdev.acsitefactory.com
+    # @param [String] user api user
+    # @param [String] password api password
+    def initialize(url, user, password)
+      @base_url = url
+      @username = user
+      @password = password
+    end
+
+    # http request via get
+    # @param [string] uri
+    # @return [Object] ruby representation of the json response
+    #                  if the reponsebody  does not parse, returns
+    #                  the non-parsed body
+    def get(uri)
+      headers = { 'Content-Type' => 'application/json' }
+      res = Excon.get(@base_url + uri.to_s,
+                      headers: headers,
+                      user: username,
+                      password: password,
+                      ssl_verify_peer: false)
+      begin
+        access_check JSON(res.body)
+      rescue JSON::ParserError
+        res.body
+      end
+    end
+
+    # http request via get
+    # @param [string] uri
+    # @return [Integer, Object] http status and the ruby representation
+    #                           of the json response if the reponse body
+    #                           does not parse, returns the non-parsed body
+    def get_with_status(uri)
+      headers = { 'Content-Type' => 'application/json' }
+      res = Excon.get(@base_url + uri.to_s,
+                      headers: headers,
+                      user: username,
+                      password: password,
+                      ssl_verify_peer: false)
+      begin
+        data = access_check JSON(res.body)
+        return res.status, data
+
+      rescue JSON::ParserError
+        return res.status, res.body
+      end
+    end
+
+    # http request via post
+    # @param [string] uri
+    # @return [Object] ruby representation of the json response
+    #                  if the reponsebody  does not parse, returns
+    #                  the non-parsed body
+    def post(uri, payload)
+      headers = { 'Content-Type' => 'application/json' }
+      res = Excon.post(@base_url + uri.to_s,
+                       headers: headers,
+                       user: username,
+                       password: password,
+                       ssl_verify_peer: false,
+                       body: payload)
+      begin
+        access_check JSON(res.body)
+      rescue JSON::ParserError
+        res.body
+      end
+    end
+
+    # http request via put
+    # @param [string] uri
+    # @return [Object] ruby representation of the json response
+    #                  if the reponsebody  does not parse, returns
+    #                  the non-parsed body
+    def put(uri, payload)
+      headers = { 'Content-Type' => 'application/json' }
+      res = Excon.put(@base_url + uri.to_s,
+                      headers: headers,
+                      user: username,
+                      password: password,
+                      ssl_verify_peer: false,
+                      body: payload)
+      begin
+        access_check JSON(res.body)
+      rescue JSON::ParserError
+        res.body
+      end
+    end
+
+    # http request via delete
+    # @param [string] uri
+    # @return [Object] ruby representation of the json response
+    #                  if the reponsebody  does not parse, returns
+    #                  the non-parsed body
+    def delete(uri)
+      headers = { 'Content-Type' => 'application/json' }
+      res = Excon.delete(@base_url + uri.to_s,
+                         headers: headers,
+                         user: username,
+                         password: password,
+                         ssl_verify_peer: false)
+      begin
+        access_check JSON(res.body)
+      rescue JSON::ParserError
+        res.body
+      end
+    end
+
+    # Throws an SFRest exception for requests that have problems
+    # @param [Object] data JSON parsed http reponse of the SFApi
+    # @return [Object] the data object if there are no issues
+    # @raise [SFRest::AccessDeniedError] if Authentication fails
+    # @raise [SFRest::ActionForbiddenError] if the users role cannot perform the request
+    # @raise [SFRest::BadRequestError]  if there is something malformed in the request
+    #
+    def access_check(data)
+      return data unless data.is_a?(Hash) # if there is an error message, it will be in a hash.
+      unless data['message'].nil?
+        raise SFRest::AccessDeniedError, data['message'] if data['message'] =~ /Access denied/
+        raise SFRest::ActionForbiddenError, data['message'] if data['message'] =~ /Forbidden: /
+        raise SFRest::BadRequestError, data['message'] if data['message'] =~ /Bad Request:/
+      end
+      data
+    end
+
+    # pings the SF api as an authenticated user
+    # responds with a pong
+    def ping
+      get('/api/v1/ping')
+    end
+
+    # Pings to retrieve a service response.
+    def service_response
+      ping
+    end
+
+    # define the other class accessor methods.
+    # this will instantiate the class with the set creds
+    # and make it possible to do
+    #  sfa = SFRest.new url, user, password
+    #  sfa.ping
+    #  sfa.site.first_site_id
+    #
+    # If a new class is added, add the accessor to this list.
+    # NOTE: accessor == Class_name.to_lower
+    REST_METHODS = %w(audit
+                      backup
+                      domains
+                      group
+                      role
+                      site
+                      stage
+                      task
+                      theme
+                      update
+                      user
+                      variable).freeze
+
+    REST_METHODS.each do |m|
+      define_method(m) do
+        m.capitalize!
+        sfrest_klass = "SFRest::#{m}"
+        Object.const_get(sfrest_klass).new(self)
+      end
+    end
+  end
+end

data/lib/sfrest/domains.rb

@@ -0,0 +1,63 @@
+module SFRest
+  # Find Staging envs and stage a set of sites
+  class Domains
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # Get the domains information on a node
+    # @param [Integer] node_id The id of the node.
+    #
+    # @return [Hash] { "node_id" => 4966, "node_type" => "site",
+    #  "time" => "2016-11-18T20:09:55+00:00",
+    #  "domains" => { "protected_domains" =>[ "it252garden4.utest.sfdev.acquia-test.co" ],
+    #  "custom_domains" => [ "it252coll3.utest.sfdev.acquia-test.co", "sc1.nikgregory.us" ] } }
+    def get(node_id)
+      current_path = "/api/v1/domains/#{node_id}"
+      @conn.get(current_path)
+    end
+
+    # Get the custom domains on a node
+    # @param [Integer] node_id The id of the node.
+    #
+    # @return [Array] custom(removable) domains on a node
+    def custom_domains(node_id)
+      get(node_id)['domains']['custom_domains']
+    end
+
+    # Get the protetect domains on a node
+    # @param [Integer] node_id The id of the node.
+    #
+    # @return [Array] protected (non-removable) domains on a node
+    def protected_domains(node_id)
+      get(node_id)['domains']['protected_domains']
+    end
+
+    # Add a domain
+    # @param [Integer] node_id The id of the node to which add a domain
+    # @param [String] domain_name domain to add. e.g. www.example.com
+    #
+    # @return [Hash] {  "node_type": "site_collection",
+    #  "domain": "www.example.com",
+    #  "added": true,
+    #  "messages": [  "Your domain name was successfully added to the site collection."] }
+    def add(node_id, domain_name)
+      payload = { 'domain_name' => domain_name }.to_json
+      @conn.post("/api/v1/domains/#{node_id}/add", payload)
+    end
+
+    # Remove a domain
+    # @param [Integer] node_id The id of the node to which remove a domain
+    # @param [String] domain_name domain to remove. e.g. www.example.com
+    #
+    # @return [Hash] {  "node_type": "site_collection",
+    #   "domain": "www.example.com",
+    #   "removed": true,
+    #   "messages": [ "Your domain name was successfully removed from the site collection." ] }
+    def remove(node_id, domain_name)
+      payload = { 'domain_name' => domain_name }.to_json
+      @conn.post("/api/v1/domains/#{node_id}/remove", payload)
+    end
+  end
+end

data/lib/sfrest/error.rb

@@ -0,0 +1,19 @@
+module SFRest
+  # Error classes for SFRest
+
+  # Extends StandardError so we can catch SFRest::SFError
+  class SFError < StandardError; end
+
+  # Throw this when a user cannot successfuly authenticate
+  class AccessDeniedError < SFRest::SFError; end
+
+  # Throw this when a user does not have permission to perform an action
+  class ActionForbiddenError < SFRest::SFError; end
+
+  # Throw this when the request is incomplete or otherwise cannot be processed by
+  # the factory
+  class BadRequestError < SFRest::SFError; end
+
+  # Throw when a task appears to be running too long
+  class TaskNotDoneError < SFRest::SFError; end
+end

data/lib/sfrest/group.rb

@@ -0,0 +1,54 @@
+module SFRest
+  # SF Group management
+  class Group
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # Creates a site group with specified group name.
+    # This currently will only create a group in the root
+    # @param [String] groupname Name of the group to be created
+    def create_group(groupname)
+      current_path = '/api/v1/groups'
+      payload = { 'group_name' => groupname }.to_json
+      @conn.post(current_path, payload)
+    end
+
+    # Gets a site group with a specified group id.
+    # @param [Integer] group_id Id of the group to fetch
+    # @return [Hash] group object from the SF Api
+    def get_group(group_id = 0)
+      current_path = '/api/v1/groups/' << group_id.to_s
+      @conn.get(current_path)
+    end
+
+    # Gets a list of all site groups.
+    # @return [Hash] all the groups on the factory plus a count
+    #                {'count' => count, 'groups' => Hash }
+    # this will iterate through the group pages
+    def group_list
+      page = 1
+      not_done = true
+      count = 0
+      while not_done
+        current_path = '/api/v1/groups?page=' << page.to_s
+        res = @conn.get(current_path)
+        if res['groups'] == []
+          not_done = false
+        elsif !res['message'].nil?
+          return { 'message' => res['message'] }
+        elsif page == 1
+          count = res['count']
+          groups = res['groups']
+        else
+          res['groups'].each do |group|
+            groups << group
+          end
+        end
+        page += 1
+      end
+      { 'count' => count, 'groups' => groups }
+    end
+  end
+end

data/lib/sfrest/pathbuilder.rb

@@ -0,0 +1,24 @@
+module SFRest
+  # make a url querypath
+  # so that if the are multiple items in a get request
+  # we can get a path like /api/v1/foo?bar=boo&bat=gah ...
+  class Pathbuilder
+    # build a get query
+    # @param [String] current_path the uri like /api/v1/foo
+    # @param [Hash] datum k,v hash of get query param and value
+    def build_url_query(current_path, datum = nil)
+      unless datum.nil?
+        current_path += '?'
+        datum.each do |key, value|
+          current_path += '&' if needs_new_parameter? current_path
+          current_path += key.to_s + '=' + value.to_s
+        end
+      end
+      current_path
+    end
+
+    private def needs_new_parameter?(path)
+      path[-1, 1] != '?' # if path has '?' then we need to create a new parameter
+    end
+  end
+end

data/lib/sfrest/role.rb

@@ -0,0 +1,101 @@
+module SFRest
+  # create, delete, update, roles
+  class Role
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # roles
+    # Gets the complete list of roles
+    # @return [Hash] all the roles on the factory plus a count
+    #                {'count' => count, 'roles' => Hash }
+    # this will iterate through the roles pages
+    def role_list
+      page = 1
+      not_done = true
+      count = 0
+      while not_done
+        current_path = '/api/v1/roles?page=' << page.to_s
+        res = @conn.get(current_path)
+        if res['roles'] == []
+          not_done = false
+        elsif !res['message'].nil?
+          return { 'message' => res['message'] }
+        elsif page == 1
+          count = res['count']
+          roles = res['roles']
+        else
+          res['roles'].each do |roleid, rolename|
+            roles[roleid] = rolename
+          end
+        end
+        page += 1
+      end
+      { 'count' => count, 'roles' => roles }
+    end
+
+    # gets the role ID for the role named rolename
+    # will page through all the roles available searching for the site
+    # @param [String] rolename the name of the role to find
+    # @return [Integer] the id of rolename
+    # this will iterate through the roles pages
+    def get_role_id(rolename)
+      pglimit = 100
+      res = @conn.get('/api/v1/roles&limit=' + pglimit.to_s)
+      rolecount = res['count'].to_i
+      id = role_data_from_results(res, rolename)
+      return id if id
+      pages = (rolecount / pglimit) + 1
+      2.upto(pages) do |i|
+        res = @conn.get('/api/v1/roles&limit=' + pglimit.to_s + '?page=' + i.to_s)
+        id = role_data_from_results(res, rolename)
+        return id if id
+      end
+      nil
+    end
+
+    # Extract the role data for rolename based on the role result object
+    # @param [Hash] res result from a request to /roles
+    # @param [String] rolename
+    # @return [Object] Integer, String, Array, Hash depending on the user data
+    def role_data_from_results(res, rolename)
+      roles = res['roles']
+      roles.each do |role|
+        return role[0].to_i if role[1] == rolename
+      end
+      nil
+    end
+
+    # Gets role data for a specific role id
+    # @param [Integer] id the role id
+    # @return [Hash] the role
+    def role_data(id)
+      @conn.get('/api/v1/roles/' + id.to_s)
+    end
+
+    # Creates a role.
+    # @param [String] name name of the role to create
+    def create_role(name)
+      current_path = '/api/v1/roles'
+      payload = { 'name' => name }.to_json
+      @conn.post(current_path, payload)
+    end
+
+    # Updates a role (changes the name).
+    # @param [Integer] id the id of the role to rename
+    # @param [String] name the new role name
+    def update_role(id, name)
+      current_path = "/api/v1/roles/#{id}/update"
+      payload = { 'new_name' => name }.to_json
+      @conn.put(current_path, payload)
+    end
+
+    # Delete a role.
+    # @param [Integer] id the role id of the role to delete
+    def delete_role(id)
+      current_path = "/api/v1/roles/#{id}"
+      @conn.delete(current_path)
+    end
+  end
+end

data/lib/sfrest/site.rb

@@ -0,0 +1,99 @@
+module SFRest
+  # Find sites, create a site,
+  class Site
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # gets the site ID for the site named sitename
+    # will page through all the sites available searching for the site
+    # @param [String] sitename the name of the site
+    # @return [Integer] the id of sitename
+    def get_site_id(sitename)
+      pglimit = 100
+      res = @conn.get('/api/v1/sites&limit=' + pglimit.to_s)
+      sitecount = res['count'].to_i
+      id = site_data_from_results(res, sitename, 'id')
+      return id if id
+      pages = (sitecount / pglimit) + 1
+      2.upto(pages) do |i|
+        res = @conn.get('/api/v1/sites&limit=' + pglimit.to_s + '?page=' + i.to_s)
+        id = site_data_from_results(res, sitename, 'id')
+        return id if id
+      end
+      nil
+    end
+
+    # Extract the site data for 'key' based on the site result object
+    # @param [Hash] res result from a request to /sites
+    # @param [String] sitename
+    # @param [String] key one of the user data returned (id, site, domain...)
+    # @return [Object] Integer, String, Array, Hash depending on the site data
+    def site_data_from_results(res, sitename, key)
+      sites = res['sites']
+      sites.each do |site|
+        return site[key] if site['site'] == sitename
+      end
+      nil
+    end
+
+    # Gets the site data for a specific site id
+    # @param [Integer] site_id the site id
+    # @return [Hash]
+    def get_site_data(site_id)
+      @conn.get('/api/v1/sites/' + site_id.to_s)
+    end
+
+    # gets the site id of the 1st one found using the api
+    # @return [Integer] the site id
+    def first_site_id
+      res = @conn.get('/api/v1/sites')
+      res['sites'].first['id']
+    end
+
+    # Gets the complete list of users
+    # Makes multiple requests to the factory to get all the sites on the factory
+    # @return [Hash{'count' => Integer, 'sites' => Hash}]
+    def site_list
+      page = 1
+      not_done = true
+      count = 0
+      while not_done
+        current_path = '/api/v1/sites?page=' << page.to_s
+        res = @conn.get(current_path)
+        if res['sites'] == []
+          not_done = false
+        elsif !res['message'].nil?
+          return { 'message' => res['message'] }
+        elsif page == 1
+          count = res['count']
+          sites = res['sites']
+        else
+          res['sites'].each do |site|
+            sites << site
+          end
+        end
+        page += 1
+      end
+      { 'count' => count, 'sites' => sites }
+    end
+
+    # Creates a site.
+    # @param [String] sitename The name of the site to create
+    # @param [Integer] group_id  The Id of the group the site is to be a member of
+    # @param [String] install_profile The install profile to use when creating the site
+    def create_site(sitename, group_id, install_profile = nil)
+      current_path = '/api/v1/sites'
+      payload = { 'site_name' => sitename, 'group_ids' => [group_id],
+                  'install_profile' => install_profile }.to_json
+      @conn.post(current_path, payload)
+    end
+
+    # accessors for backups/restore
+    # so that you can do site.backup.list_backups
+    def backup
+      @conn.backup
+    end
+  end
+end

data/lib/sfrest/stage.rb

@@ -0,0 +1,31 @@
+module SFRest
+  # Find Staging envs and stage a set of sites
+  class Stage
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # Stage a site
+    # @param [String] to_env the name of of target env. defaults to test
+    # @param [Array] sites Array of site nids to stage
+    # @param [Boolean] email_site_status send an email about the staging status of each site
+    # @param [Boolean] skip_gardener skip staging the gardener and only stage the sites
+    #
+    # @return [Integer] Id of the staging task created.
+    def stage(to_env = 'test', sites = nil, email_site_status = false, skip_gardener = false)
+      payload = { 'to_env' => to_env, 'sites' => sites,
+                  'detailed_status' => email_site_status,
+                  'skip_gardener' => skip_gardener }.to_json
+      @conn.post('/api/v1/stage', payload)
+    end
+
+    # Query for available staging environments
+    #
+    # @return environments
+    def list_staging_environments
+      current_path = '/api/v1/stage'
+      @conn.get(current_path)
+    end
+  end
+end

data/lib/sfrest/task.rb

@@ -0,0 +1,261 @@
+module SFRest
+  # Deal with tasks, find them, pause them...
+  class Task
+    STATUS_NOT_STARTED = 1 # Task has been added to queue but not picked up
+    STATUS_RESTARTED   = 2 # Task has been re-added to the queue but not picked up
+    STATUS_TO_BE_RUN   = 3 # Restarted + not started
+    STATUS_IN_PROCESS  = 4 # A wip process is actively processing a task
+    STATUS_WAITING     = 8 # Task has been released from active processing
+    STATUS_RUNNING     = 12 # Running = in process + waiting to be processed
+    STATUS_COMPLETED   = 16 # Task is successfully processed (exited with success)
+    STATUS_ERROR       = 32 # Task unsccuessfully completed (exited with failure)
+    STATUS_KILLED      = 64 # Task is terminated
+    STATUS_WARNING     = 144 # Completed bit + 128 bit(warning).
+    STATUS_DONE        = 240 # Completed + error + killed + 128 bit(warning)
+
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # Returns true only if the status evaluates to completed
+    # @param [Integer] status
+    # @return [Boolean]
+    def status_completed?(status)
+      return true if status.to_i == STATUS_COMPLETED
+      false
+    end
+
+    # Returns true if the status evaluates to either
+    # waiting or in process
+    # @param [Integer] status
+    # @return [Boolean]
+    def status_running?(status)
+      return true if (status.to_i & STATUS_RUNNING) > 0
+      false
+    end
+
+    # Returns true only if the status evaluates to errored
+    # @param [Integer] status
+    # @return [Boolean]
+    def status_error?(status)
+      return true if status.to_i == STATUS_ERROR
+      false
+    end
+
+    # Returns true only if the status evaluates to killed
+    # @param [Integer] status
+    # @return [Boolean]
+    def status_killed?(status)
+      return true if status.to_i == STATUS_KILLED
+      false
+    end
+
+    # Returns true if the status evaluates to a state that is
+    # considered done
+    # @param [Integer] status
+    # @return [Boolean]
+    def status_done?(status)
+      return true if (status.to_i & STATUS_DONE) > 0
+      false
+    end
+
+    # Returns true only if WIP reports the status as running
+    # @param [Integer] task_id
+    # @return [Boolean]
+    def task_running?(task_id)
+      task_path = "/api/v1/wip/task/#{task_id}/status"
+
+      res = @conn.get task_path
+      status = res['wip_task']['status']
+      status_running?(status)
+    end
+
+    # Returns true only if WIP reports the status as completed
+    # @param [Integer] task_id
+    # @return [Boolean]
+    def task_completed?(task_id)
+      task_path = "/api/v1/wip/task/#{task_id}/status"
+
+      res = @conn.get task_path
+      status = res['wip_task']['status']
+      status_completed?(status)
+    end
+
+    # Returns true if WIP reports the status in a state that is
+    # considered done
+    # @param [Integer] task_id
+    # @return [Boolean]
+    def task_done?(task_id)
+      task_path = "/api/v1/wip/task/#{task_id}/status"
+
+      res = @conn.get task_path
+      status = res['wip_task']['status']
+      status_done?(status)
+    end
+
+    # Returns true only if WIP reports the status as killed
+    # @param [Integer] task_id
+    # @return [Boolean]
+    def task_killed?(task_id)
+      task_path = "/api/v1/wip/task/#{task_id}/status"
+
+      res = @conn.get task_path
+      status = res['wip_task']['status']
+      status_killed?(status)
+    end
+
+    # Returns true only if WIP reports the status as errored
+    # @param [Integer] task_id
+    # @return [Boolean]
+    def task_errored?(task_id)
+      task_path = "/api/v1/wip/task/#{task_id}/status"
+
+      res = @conn.get task_path
+      status = res['wip_task']['status']
+      status_error?(status)
+    end
+
+    # Find a set of task ids.
+    # @param [Integer] limit max amount of results to return per request
+    # @param [Integer] page page of request
+    # @param [String] group task group
+    # @param [String] klass task class
+    # @param [Integer] status Integerish the status of the task
+    #         see SFRest::Task::STATUS_*
+    # @return [Array[Integer]]
+    def find_task_ids(limit = nil, page = nil, group = nil, klass = nil, status = nil)
+      res = find_tasks limit: limit, page: page, group: group, klass: klass, status: status
+      task_ids = []
+      i = 0
+      res.each do |task|
+        task_ids[i] = task['id']
+        i += 1
+      end
+      task_ids
+    end
+
+    # Find a set of tasks.
+    # @param [Hash] datum Hash of filters
+    # @option datum [Integer] :limit max amount of results to return per request
+    # @option datum [Integer] :page page of request
+    # @option datum [String] :group task group
+    # @option datum [String] :class task class
+    # @option datum [Integer] :status Integerish the status of the task
+    #         see SFRest::Task::STATUS_*
+    def find_tasks(datum = nil)
+      current_path = '/api/v1/tasks'
+      pb = SFRest::Pathbuilder.new
+      @conn.get URI.parse(URI.encode(pb.build_url_query(current_path, datum))).to_s
+    end
+
+    # Looks for a task with a specific name
+    # @param [String] name display name of the task
+    # @param [String] group task group filter
+    # @param [String] klass task class filter
+    # @param [String] status task status filter
+    def get_task_id(name, group = nil, klass = nil, status = nil)
+      page_size = 100
+      page = 0
+      loop do
+        tasks = find_tasks(limit: page_size, page: page, group: group, class: klass, status: status)
+        tasks.each do |task|
+          return task['id'].to_i if task['name'] =~ /#{name}/
+          page += 1
+        end
+        break if tasks.size < page_size
+      end
+      nil
+    end
+
+    # Pauses all tasks.
+    def pause_all_tasks
+      current_path = '/api/v1/pause'
+      payload = { 'paused' => true }.to_json
+      @conn.post(current_path, payload)
+    end
+
+    # Resumes all tasks.
+    def resume_all_tasks
+      current_path = '/api/v1/pause'
+      payload = { 'paused' => false }.to_json
+      @conn.post(current_path, payload)
+    end
+
+    # Get a specific task's logs
+    # @param [Integer] task_id
+    def get_task_logs(task_id)
+      current_path = '/api/v1/tasks/' << task_id.to_s << '/logs'
+      @conn.get(current_path)
+    end
+
+    # Gets the value of a vairable
+    # @TODO: this is missnamed becasue it does not check the global paused variable
+    # @param [String] variable_name
+    # @return [Object]
+    def globally_paused?(variable_name)
+      current_path = "/api/v1/variables?name=#{variable_name}"
+      res = @conn.get(current_path)
+      res[variable_name]
+    end
+
+    # Pauses a specific task identified by its task id.
+    # This can pause either the task and it's children or just the task
+    # @param [Integer] task_id
+    # @param [String] level family|task
+    def pause_task(task_id, level = 'family')
+      current_path = '/api/v1/pause/' << task_id.to_s
+      payload = { 'paused' => true, 'level' => level }.to_json
+      @conn.post(current_path, payload)
+    end
+
+    # Resumes a specific task identified by its task id.
+    # This can resume either the task and it's children or just the task
+    # @param [Integer] task_id
+    # @param [String] level family|task
+    def resume_task(task_id, level = 'family')
+      current_path = '/api/v1/pause/' << task_id.to_s
+      payload = { 'paused' => false, 'level' => level }.to_json
+      @conn.post(current_path, payload)
+    end
+
+    # returns the classes that are either softpaused or softpause-for-update
+    # @param [String] type softpaused | softpause-for-update
+    # @return [Array] Array of wip classes
+    def get_task_class_info(type = '')
+      current_path = '/api/v1/classes/' << type
+      @conn.get(current_path)
+    end
+
+    # Get the status of a wip task by id.
+    # @param [Integer] task_id
+    # @return [Hash{"wip_task" => {"id" => Integer, "status" => Integer}, "time" => timestamp}]
+    def get_wip_task_status(task_id)
+      current_path = "/api/v1/wip/task/#{task_id}/status"
+      @conn.get(current_path)
+    end
+
+    # Blocks until a task is done
+    # @param [Integer] task_id
+    # @param [Integer] max_nap seconds to try before giving up
+    def wait_until_done(task_id, max_nap = 600)
+      wait_until_state(task_id, 'done', max_nap)
+    end
+
+    # Blocks until a task reaches a specific status
+    # @param [Integer] task_id
+    # @param [String] state state to reach
+    # @param [Integer] max_nap seconds to try before giving up
+    def wait_until_state(task_id, state, max_nap)
+      blink_time = 5 # wake up and scan
+      nap_start = Time.now
+      state_method = method("task_#{state}?".to_sym)
+      loop do
+        break if state_method.call(task_id)
+        raise TaskNotDoneError, "Task: #{task_id} has taken too long to complete!" if Time.new > (nap_start + max_nap)
+        sleep blink_time
+      end
+      task_id
+    end
+  end
+end

data/lib/sfrest/theme.rb

@@ -0,0 +1,23 @@
+module SFRest
+  # Tell the Factory that there is theme work to do
+  class Theme
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # Sends a theme notification.
+    def send_theme_notification(scope = 'site', event = 'modify', nid = 0, theme = '')
+      current_path = '/api/v1/theme/notification'
+      payload = { 'scope' => scope, 'event' => event, 'nid' => nid, 'theme' => theme }.to_json
+      @conn.post(current_path, payload)
+    end
+
+    # Processes a theme notification.
+    def process_theme_notification(sitegroup_id = 0)
+      current_path = '/api/v1/theme/process'
+      payload = { 'sitegroup_id' => sitegroup_id }.to_json
+      @conn.post(current_path, payload)
+    end
+  end
+end

data/lib/sfrest/update.rb

@@ -0,0 +1,78 @@
+module SFRest
+  # Drive updates on the Site Factory
+  class Update
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # Gets the status information.
+    def status_info
+      current_path = '/api/v1/status'
+      @conn.get(current_path)
+    end
+
+    # Modifies the status information.
+    def modify_status(site_creation, site_duplication, domain_management, bulk_operations)
+      current_path = '/api/v1/status'
+      payload = { 'site_creation' => site_creation,
+                  'site_duplication' => site_duplication,
+                  'domain_management' => domain_management,
+                  'bulk_operations' => bulk_operations }.to_json
+      @conn.put(current_path, payload)
+    end
+
+    # Lists vcs refs.
+    def list_vcs_refs(type = 'sites')
+      current_path = '/api/v1/vcs?type=' << type
+      @conn.get(current_path)
+    end
+
+    # Starts an update.
+    def start_update(ref)
+      update_data = { scope: 'sites', sites_type: 'code, db', sites_ref: ref }
+      update(update_data)
+    end
+
+    # Starts an update. The rest api supports the following
+    # scope: sites|factory|both (defaults to 'sites')
+    # start_time:
+    # sites_type: code|code, db| code, db, registry (defaults to 'code, db')
+    # factory_type: code|code, db (defaults to 'code, db')
+    # sites_ref:
+    # factory_ref:
+    # This method does not filter or validate so that it can be used for
+    # negative cases. (missing data)
+    def update(datum)
+      current_path = '/api/v1/update'
+      payload = datum.to_json
+      @conn.post(current_path, payload)
+    end
+
+    # Gets the list of updates.
+    def update_list
+      current_path = '/api/v1/update'
+      @conn.get(current_path)
+    end
+
+    # Gets the progress of an update by id.
+    def update_progress(update_id)
+      current_path = '/api/v1/update/' + update_id.to_s + '/status'
+      @conn.get(current_path)
+    end
+
+    # Pauses current update.
+    def pause_update
+      current_path = '/api/v1/update/pause'
+      payload = { 'pause' => true }.to_json
+      @conn.post(current_path, payload)
+    end
+
+    # Resumes current update.
+    def resume_update
+      current_path = '/api/v1/update/pause'
+      payload = { 'pause' => false }.to_json
+      @conn.post(current_path, payload)
+    end
+  end
+end

data/lib/sfrest/user.rb

@@ -0,0 +1,106 @@
+module SFRest
+  # Do User actions within the Site Factory
+  class User
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # Gets the complete list of users
+    # Makes multiple requests to the factory to get all the users on the factory
+    # @return [Hash{'count' => Integer, 'users' => Hash}]
+    def user_list
+      page = 1
+      not_done = true
+      count = 0
+      while not_done
+        current_path = '/api/v1/users?page=' << page.to_s
+        res = @conn.get(current_path)
+        if res['users'] == []
+          not_done = false
+        elsif !res['message'].nil?
+          return { 'message' => res['message'] }
+        elsif page == 1
+          count = res['count']
+          users = res['users']
+        else
+          res['users'].each do |user|
+            users << user
+          end
+        end
+        page += 1
+      end
+      { 'count' => count, 'users' => users }
+    end
+
+    # gets the site ID for the site named sitename
+    # will page through all the sites available searching for the site
+    # @param [String] username drupal username (not email)
+    # @return [Integer] the uid of the drupal user
+    def get_user_id(username)
+      pglimit = 100
+      res = @conn.get('/api/v1/users&limit=' + pglimit.to_s)
+      usercount = res['count'].to_i
+      id = user_data_from_results(res, username, 'uid')
+      return id if id
+      pages = (usercount / pglimit) + 1
+      2.upto(pages) do |i|
+        res = @conn.get('/api/v1/users&limit=' + pglimit.to_s + '?page=' + i.to_s)
+        id = user_data_from_results(res, username, 'uid')
+        return id if id
+      end
+      nil
+    end
+
+    # Extract the user data for 'key' based on the user result object
+    # @param [Hash] res result from a request to /users
+    # @param [String] username
+    # @param [String] key one of the user data returned (uid, mail, tfa_status...)
+    # @return [Object] Integer, String, Array, Hash depending on the user data
+    def user_data_from_results(res, username, key)
+      users = res['users']
+      users.each do |user|
+        return user[key] if user['name'] == username
+      end
+      nil
+    end
+
+    # Gets the data for user UID
+    # @param [int] uid site id
+    # @return [Hash]
+    def get_user_data(uid)
+      @conn.get('/api/v1/users/' + uid.to_s)
+    end
+
+    # Creates a user.
+    # @param [String] name
+    # @param [String] email
+    # @param [Hash] datum hash with elements :pass => string,
+    #                                        :status => 0|1,
+    #                                        :roles => Array
+    def create_user(name, email, datum = nil)
+      current_path = '/api/v1/users'
+      payload = { name: name, mail: email }
+      payload.merge!(datum) unless datum.nil?
+      @conn.post(current_path, payload.to_json)
+    end
+
+    # Updates a user.
+    # @param [Integer] uid user id of the drupal user to update
+    # @param [Hash] datum hash with elements :name => string, :pass => string,
+    #                                        :status => 0|1, :roles => Array,
+    #                                        :mail => string@string, :tfa_status => 0|1
+    def update_user(uid, datum = nil)
+      current_path = "/api/v1/users/#{uid}/update"
+      payload = datum.to_json unless datum.nil?
+      @conn.put(current_path, payload)
+    end
+
+    # Delete a user.
+    # @param [integer] uid Uid of the user to be deleted
+    def delete_user(uid)
+      current_path = "/api/v1/users/#{uid}"
+      @conn.delete(current_path)
+    end
+  end
+end

data/lib/sfrest/variable.rb

@@ -0,0 +1,28 @@
+module SFRest
+  # Perform actions against variables in the Factory
+  class Variable
+    # @param [SFRest::Connection] conn
+    def initialize(conn)
+      @conn = conn
+    end
+
+    # Gets the list of variables.
+    def variable_list
+      current_path = '/api/v1/variables'
+      @conn.get(current_path)
+    end
+
+    # Gets the value of a specific variable.
+    def get_variable(name)
+      current_path = '/api/v1/variables?name=' << name
+      @conn.get(current_path)
+    end
+
+    # Sets the key and value of a variable.
+    def set_variable(name, value)
+      current_path = '/api/v1/variables'
+      payload = { 'name' => name, 'value' => value }.to_json
+      @conn.put(current_path, payload)
+    end
+  end
+end

data/lib/sfrest/version.rb

@@ -0,0 +1,3 @@
+module SFRest
+  VERSION = '0.0.8'.freeze
+end

data/lib/sfrest.rb

@@ -0,0 +1,43 @@
+# Simple wrappper around RestClient.Resource
+$LOAD_PATH.unshift(File.dirname(__FILE__)) unless
+    $LOAD_PATH.include?(File.dirname(__FILE__)) ||
+    $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'excon'
+require 'json'
+
+require 'sfrest/audit'
+require 'sfrest/backup'
+require 'sfrest/connection'
+require 'sfrest/domains'
+require 'sfrest/error'
+require 'sfrest/group'
+require 'sfrest/pathbuilder'
+require 'sfrest/role'
+require 'sfrest/site'
+require 'sfrest/stage'
+require 'sfrest/task'
+require 'sfrest/theme'
+require 'sfrest/update'
+require 'sfrest/user'
+require 'sfrest/variable'
+
+# Base Class for SF rest API sdk
+module SFRest
+  # Class set to work as an sdk for the Site Factory Rest api
+  # most of the interesting pieces happen in the connection class and others
+  class << self
+    attr_accessor :base_url, :user, :password, :conn
+
+    # returns a connection object to the SF Rest api for a specific factory
+    # @param [String] url Base url of the Site Factory
+    # @param [String] user username of a user on the factory
+    # @param [String] password api password for the user on the factory
+    def new(url, user, password)
+      @base_url = url
+      @user = user
+      @password = password
+      @conn = SFRest::Connection.new(@base_url, @user, @password)
+    end
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: sfrest
+version: !ruby/object:Gem::Version
+  version: 0.0.8
+platform: ruby
+authors:
+- ACSF Engineering
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+description: Wrapper methods around the ACSF Rest API.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sfrest.rb
+- lib/sfrest/audit.rb
+- lib/sfrest/backup.rb
+- lib/sfrest/connection.rb
+- lib/sfrest/domains.rb
+- lib/sfrest/error.rb
+- lib/sfrest/group.rb
+- lib/sfrest/pathbuilder.rb
+- lib/sfrest/role.rb
+- lib/sfrest/site.rb
+- lib/sfrest/stage.rb
+- lib/sfrest/task.rb
+- lib/sfrest/theme.rb
+- lib/sfrest/update.rb
+- lib/sfrest/user.rb
+- lib/sfrest/variable.rb
+- lib/sfrest/version.rb
+homepage: http://github.com/acquia/sf-sdk-ruby
+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.1
+signing_key: 
+specification_version: 4
+summary: Acquia Site Factory Rest API.
+test_files: []