gooddata 0.6.6 → 0.6.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9735f379edc31d6cef7c4aea2ce2230910e30a6f
-  data.tar.gz: bfdc00d8beec59011127c8845eed2fac393cf0d0
+  metadata.gz: 57bce714f8ec1d419534b3a6f3730c430b5f67dd
+  data.tar.gz: 53a29990c0fb352dc481ff56b8361ccc25c6ff11
 SHA512:
-  metadata.gz: ff1ab5206777958b9690d453d9416e538452a97571192c380a5c80aecd716842c3225720bfee445f75d2eb51bec9f2777c81d8e11d1c8ca588cad0c8c506565d
-  data.tar.gz: 05141dcd016696cfa0b8f2edfcdd24785814100056e2b4e798592185e328feff0c6e5b17756884d4f526263ef9f06486b48b927f46725c857e7f25fc3918dc67
+  metadata.gz: ef33ff8a02e8385d2ba0b2fe80091a15f9ac6c69f10d69faf3dd95967e35e0a1095c3d409811d15e917a80fa7001d98e94d81a6396d28494943275d9b0f9bcf9
+  data.tar.gz: 2d9e907507561efc2c0e6de51037dde476c2d5a09a719abc27871fc964c671c14696feb2ef321373cf14bed0504ad45723a230c7f2a7292c3e1e4dba1321e8dc

data/{CHANGELOG.markdown → CHANGELOG.md}

@@ -1,8 +1,13 @@
 # GoodData Ruby SDK Changelog
 
-## 0.6.6
+## 0.6.7
 - Fixed the scaffolding templates to take advantage of new syntax (missing references in dataset refs) 
 - Fixing inclusion of extensions when using CLI
+- Fixed pollers and added/fixed tests for schedules and processes
+- Added with_connection which automatically disconnects when you are done
+
+## 0.6.6
+ - Various fixes
 
 ## 0.6.5
 - Mixins

data/lib/gooddata/cli/commands/project_cmd.rb

@@ -14,33 +14,9 @@ GoodData::CLI.module_eval do
     c.desc 'If you are in a gooddata project blueprint or if you provide a project id it will start an interactive session inside that project'
     c.command :jack_in do |jack|
       jack.action do |global_options, options, args|
-        goodfile_path = GoodData::Helpers.find_goodfile(Pathname('.'))
-
-        spin_session = proc do |goodfile, blueprint|
-          project_id = global_options[:project_id] || goodfile[:project_id]
-          fail "You have to provide 'project_id'. You can either provide it through -p flag or even better way is to fill it in in your Goodfile under key \"project_id\". If you just started a project you have to create it first. One way might be through \"gooddata project build\"" if project_id.nil? || project_id.empty?
-
-          opts = options.merge(global_options)
-          GoodData.connect(opts)
-
-          begin
-            require 'gooddata'
-            GoodData::Command::Project.jack_in(project_id)
-          rescue GoodData::ProjectNotFound
-            puts "Project with id \"#{project_id}\" could not be found. Make sure that the id you provided is correct."
-          end
-        end
-
-        if goodfile_path
-          goodfile = MultiJson.load(File.read(goodfile_path), :symbolize_keys => true)
-          model_key = goodfile[:model]
-          blueprint = GoodData::Model::ProjectBlueprint.new(eval(File.read(model_key)).to_hash) if File.exist?(model_key) && !File.directory?(model_key)
-          FileUtils.cd(goodfile_path.dirname) do
-            spin_session.call(goodfile, blueprint)
-          end
-        else
-          spin_session.call({}, nil)
-        end
+        opts = options.merge(global_options)
+        GoodData.connect(opts)
+        GoodData::Command::Project.jack_in(opts)
       end
     end
 
@@ -95,11 +71,12 @@ GoodData::CLI.module_eval do
         opts = options.merge(global_options)
         id = global_options[:project_id]
         token = opts[:token]
-
+        opts[:auth_token] = token
         fail 'You have to provide a token for creating a project. Please use parameter --token' if token.nil? || token.empty?
 
         GoodData.connect(opts)
-        GoodData::Command::Project.clone(id, opts)
+        new_project = GoodData::Command::Project.clone(id, opts)
+        puts "Project with title \"#{new_project.title}\" was cloned with id #{new_project.pid}"
       end
     end
 

data/lib/gooddata/commands/project.rb

@@ -32,44 +32,9 @@ module GoodData
 
         # Clone existing project
         def clone(project_id, options)
-          with_data = options[:data] || true
-          with_users = options[:users] || false
-          export = {
-            :exportProject => {
-              :exportUsers => with_users ? 1 : 0,
-              :exportData => with_data ? 1 : 0
-            }
-          }
-
-          result = GoodData.post("/gdc/md/#{project_id}/maintenance/export", export)
-          export_token = result['exportArtifact']['token']
-          status_url = result['exportArtifact']['status']['uri']
-
-          state = GoodData.get(status_url)['taskState']['status']
-          while state == 'RUNNING'
-            sleep 5
-            result = GoodData.get(status_url)
-            state = result['taskState']['status']
-          end
-
-          old_project = GoodData::Project[project_id]
-          project_uri = create(options.merge(:title => "Clone of #{old_project.title}"))
-          new_project = GoodData::Project[project_uri]
-
-          import = {
-            :importProject => {
-              :token => export_token
-            }
-          }
-          result = GoodData.post("/gdc/md/#{new_project.obj_id}/maintenance/import", import)
-          status_url = result['uri']
-          state = GoodData.get(status_url)['taskState']['status']
-          while state == 'RUNNING'
-            sleep 5
-            result = GoodData.get(status_url)
-            state = result['taskState']['status']
+          GoodData.with_project(project_id) do |project|
+            project.clone(options)
           end
-          true
         end
 
         # Delete existing project
@@ -142,13 +107,40 @@ module GoodData
           end
         end
 
-        def jack_in(project_id)
-          GoodData.with_project(project_id) do |project|
-            puts "Use 'exit' to quit the live session. Use 'q' to jump out of displaying a large output."
-            binding.pry(:quiet => true,
-                        :prompt => [proc do |target_self, nest_level, pry|
-                          'project_live_sesion: '
-                        end])
+        def jack_in(options)
+          goodfile_path = GoodData::Helpers.find_goodfile(Pathname('.'))
+
+          spin_session = proc do |goodfile, blueprint|
+            project_id = options[:project_id] || goodfile[:project_id]
+            message = 'You have to provide "project_id". You can either provide it through -p flag'\
+               'or even better way is to fill it in in your Goodfile under key "project_id".'\
+               'If you just started a project you have to create it first. One way might be'\
+               'through "gooddata project build"'
+            fail message if project_id.nil? || project_id.empty?
+
+            begin
+              require 'gooddata'
+              GoodData.with_project(project_id) do |project|
+                puts "Use 'exit' to quit the live session. Use 'q' to jump out of displaying a large output."
+                binding.pry(:quiet => true,
+                            :prompt => [proc do |target_self, nest_level, pry|
+                              'project_live_sesion: '
+                            end])
+              end
+            rescue GoodData::ProjectNotFound
+              puts "Project with id \"#{project_id}\" could not be found. Make sure that the id you provided is correct."
+            end
+          end
+
+          if goodfile_path
+            goodfile = MultiJson.load(File.read(goodfile_path), :symbolize_keys => true)
+            model_key = goodfile[:model]
+            blueprint = GoodData::Model::ProjectBlueprint.new(eval(File.read(model_key)).to_hash) if File.exist?(model_key) && !File.directory?(model_key)
+            FileUtils.cd(goodfile_path.dirname) do
+              spin_session.call(goodfile, blueprint)
+            end
+          else
+            spin_session.call({}, nil)
           end
         end
       end

data/lib/gooddata/connection.rb

@@ -67,5 +67,12 @@ module GoodData
       connection.status = :logged_in
       connection
     end
+
+    def with_connection(options = nil, second_options = nil, third_options = {}, &bl)
+      connection = connect(options, second_options, third_options)
+      bl.call(connection)
+    ensure
+      disconnect
+    end
   end
 end

data/lib/gooddata/core/connection.rb

@@ -346,6 +346,9 @@ module GoodData
       if content_type == 'application/json' || content_type == 'application/json;charset=UTF-8'
         result = response.to_str == '""' ? {} : MultiJson.load(response.to_str)
         GoodData.logger.debug "Response: #{result.inspect}"
+      elsif ['text/plain;charset=UTF-8', 'text/plain; charset=UTF-8', 'text/plain'].include?(content_type)
+        result = response
+        GoodData.logger.debug 'Response: plain text'
       elsif content_type == 'application/zip'
         result = response
         GoodData.logger.debug 'Response: a zipped stream'

data/lib/gooddata/core/rest.rb

@@ -3,6 +3,8 @@
 require_relative 'connection'
 
 module GoodData
+  DEFAULT_SLEEP_INTERVAL = 10
+
   class << self
     # Performs a HTTP GET request.
     #
@@ -95,36 +97,53 @@ module GoodData
       connection.download(file, where, options.merge(:staging_url => url))
     end
 
-    def poll(result, key = nil, options = {}, &bl)
-      sleep_interval = options[:sleep_interval] || 10
-      link = bl ? bl.call(result) : result[key]['links']['poll']
+    # Generalizaton of poller. Since we have quite a variation of how async proceses are handled
+    # this is a helper that should help you with resources where the information about "Are we done"
+    # is the http code of response. By default we repeat as long as the code == 202. You can
+    # change the code if necessary. It expects the URI as an input where it can poll. It returns the
+    # value of last poll. In majority of cases these are the data that you need.
+    #
+    # @param link [String] Link for polling
+    # @param options [Hash] Options
+    # @return [Hash] Result of polling
+    def poll_on_code(link, options = {})
+      code = options[:code] || 202
+      sleep_interval = options[:sleep_interval] || DEFAULT_SLEEP_INTERVAL
       response = GoodData.get(link, :process => false)
-      while response.code != 204
+      while response.code == code
         sleep sleep_interval
         GoodData.connection.retryable(:tries => 3, :on => RestClient::InternalServerError) do
           sleep sleep_interval
           response = GoodData.get(link, :process => false)
         end
       end
-    end
-
-    def poll_on_root(result, root, &bl)
-      polling_url = bl.call(result)
-      polling_result = GoodData.get(polling_url)
-      while polling_result[root]
-        sleep(3)
-        polling_result = GoodData.get(polling_url)
+      if options[:process] == false
+        response
+      else
+        GoodData.get(link)
       end
-      polling_result
     end
 
-    def wait_for_polling_result(polling_url)
-      polling_result = GoodData.get(polling_url)
-      while polling_result['wTaskStatus'] && polling_result['wTaskStatus']['status'] == 'RUNNING'
-        sleep(3)
-        polling_result = GoodData.get(polling_url)
+    # Generalizaton of poller. Since we have quite a variation of how async proceses are handled
+    # this is a helper that should help you with resources where the information about "Are we done"
+    # is inside the response. It expects the URI as an input where it can poll and a block that should
+    # return either true -> 'meaning we are done' or false -> meaning sleep and repeat. It returns the
+    # value of last poll. In majority of cases these are the data that you need
+    #
+    # @param link [String] Link for polling
+    # @param options [Hash] Options
+    # @return [Hash] Result of polling
+    def poll_on_response(link, options = {}, &bl)
+      sleep_interval = options[:sleep_interval] || DEFAULT_SLEEP_INTERVAL
+      response = GoodData.get(link)
+      while bl.call(response)
+        sleep sleep_interval
+        GoodData.connection.retryable(:tries => 3, :on => RestClient::InternalServerError) do
+          sleep sleep_interval
+          response = GoodData.get(link)
+        end
       end
-      polling_result
+      response
     end
   end
 end

data/lib/gooddata/mixins/md_object_query.rb

@@ -24,8 +24,9 @@ module GoodData
       # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
       def query(query_obj_type, klass, options = {})
-        fail(NoProjectError, 'Connect to a project before searching for an object') unless GoodData.project
-        query_result = GoodData.get(GoodData.project.md['query'] + "/#{query_obj_type}/")['query']['entries']
+        project = options[:project] || GoodData.project
+        fail(NoProjectError, 'Connect to a project before searching for an object') unless project
+        query_result = GoodData.get(project.md['query'] + "/#{query_obj_type}/")['query']['entries']
         options[:full] ? query_result.map { |item| klass[item['link']] } : query_result
       end
 

data/lib/gooddata/models/metadata/dashboard.rb

@@ -86,14 +86,9 @@ module GoodData
       fail "Wrong format provied \"#{format}\". Only supports formats #{supported_formats.join(', ')}" unless supported_formats.include?(format)
       tab = options[:tab] || ''
 
-      req_uri = "/gdc/projects/#{GoodData.project.uri}/clientexport"
-      x = GoodData.post(req_uri, { 'clientExport' => { 'url' => "https://secure.gooddata.com/dashboard.html#project=#{GoodData.project.uri}&dashboard=#{uri}&tab=#{tab}&export=1", 'name' => title } }, :process => false)
-      while x.code == 202
-        sleep(1)
-        uri = MultiJson.load(x.body)['asyncTask']['link']['poll']
-        x = GoodData.get(uri, :process => false)
-      end
-      x
+      req_uri = "/gdc/projects/#{GoodData.project.pid}/clientexport"
+      x = GoodData.post(req_uri, 'clientExport' => { 'url' => "https://secure.gooddata.com/dashboard.html#project=#{GoodData.project.uri}&dashboard=#{uri}&tab=#{tab}&export=1", 'name' => title })
+      GoodData.poll_on_code(x['asyncTask']['link']['poll'], process: false)
     end
 
     def tabs

data/lib/gooddata/models/metadata/report.rb

@@ -103,12 +103,7 @@ module GoodData
     def export(format)
       result = GoodData.post('/gdc/xtab2/executor3', 'report_req' => { 'report' => uri })
       result1 = GoodData.post('/gdc/exporter/executor', :result_req => { :format => format, :result => result })
-      png = GoodData.get(result1['uri'], :process => false)
-      while png.code == 202
-        sleep(1)
-        png = GoodData.get(result1['uri'], :process => false)
-      end
-      png
+      GoodData.poll_on_code(result1['uri'], process: false)
     end
   end
 end

data/lib/gooddata/models/model.rb

@@ -108,11 +108,12 @@ module GoodData
         pull = { 'pullIntegration' => File.basename(dir) }
         link = project.md.links('etl')['pull']
         task = GoodData.post link, pull
-        # TODO: Refactor the task status out
-        while GoodData.get(task['pullTask']['uri'])['taskStatus'] == 'RUNNING' || GoodData.get(task['pullTask']['uri'])['taskStatus'] == 'PREPARED'
-          sleep 30
+
+        res = GoodData.poll_on_response(task['pullTask']['uri']) do |body|
+          body['taskStatus'] == 'RUNNING' || body['taskStatus'] == 'PREPARED'
         end
-        if GoodData.get(task['pullTask']['uri'])['taskStatus'] == 'ERROR'
+
+        if res['taskStatus'] == 'ERROR'
           s = StringIO.new
           GoodData.download_from_user_webdav(File.basename(dir) + '/upload_status.json', s)
           js = MultiJson.load(s.string)

data/lib/gooddata/models/process.rb

@@ -6,6 +6,10 @@ module GoodData
   class Process
     attr_reader :data
 
+    alias_method :raw_data, :data
+    alias_method :json, :data
+    alias_method :to_hash, :data
+
     class << self
       def [](id, options = {})
         if id == :all
@@ -27,7 +31,7 @@ module GoodData
       # TODO: Check the params.
       def with_deploy(dir, options = {}, &block)
         # verbose = options[:verbose] || false
-        GoodData.with_project(options[:project_id]) do |project|
+        GoodData.with_project(options[:project_id] || options[:project]) do |project|
           params = options[:params].nil? ? [] : [options[:params]]
           if block
             begin
@@ -71,7 +75,6 @@ module GoodData
       #
       # @param path [String] Path to ZIP archive or to a directory containing files that should be ZIPed
       # @option options [String] :files_to_exclude
-      # @option options [String] :process_id ('nobody') From address
       # @option options [String] :type ('GRAPH') Type of process - GRAPH or RUBY
       # @option options [String] :name Readable name of the process
       # @option options [String] :process_id ID of a process to be redeployed (do not set if you want to create a new process)
@@ -164,19 +167,12 @@ module GoodData
     end
 
     def schedules
-      res = []
-
-      scheds = GoodData::Schedule[:all]
-      scheds['schedules']['items'].each do |item|
-        if item['schedule']['params']['PROCESS_ID'] == obj_id
-          res << GoodData::Schedule.new(item)
-        end
-      end
-
-      res
+      GoodData::Schedule[:all].select { |schedule| schedule.process_id == obj_id }
     end
 
-    alias_method :raw_data, :data
+    def create_schedule(cron, executable, options = {})
+      GoodData::Schedule.create(process_id, cron, executable, options)
+    end
 
     def execute(executable, options = {})
       params = options[:params] || {}
@@ -188,7 +184,7 @@ module GoodData
                                :hiddenParams => hidden_params
                              })
       begin
-        GoodData.poll(result, 'executionTask')
+        GoodData.poll_on_code(result['executionTask']['links']['poll'])
       rescue RestClient::RequestFailed => e
         raise(e)
       ensure

data/lib/gooddata/models/project.rb

@@ -119,6 +119,10 @@ module GoodData
         project
       end
 
+      def create_from_blueprint(blueprint, options = {})
+        GoodData::Model::ProjectCreator.migrate(:spec => blueprint, :token => options[:auth_token])
+      end
+
       # Takes one CSV line and creates hash from data extracted
       #
       # @param row CSV row
@@ -139,14 +143,16 @@ module GoodData
 
     def add_metric(options = {})
       options[:expression] || fail('Metric has to have its expression defined')
-      m1 = GoodData::Metric.create(options)
+      m1 = GoodData::Metric.xcreate(options)
       m1.save
     end
+    alias_method :create_metric, :add_metric
 
     def add_report(options = {})
       rep = GoodData::Report.create(options)
       rep.save
     end
+    alias_method :create_report, :add_report
 
     # Returns an indication whether current user is admin in this project
     #
@@ -160,7 +166,8 @@ module GoodData
     # @return [GoodData::ProjectRole] Project role if found
     def blueprint
       result = GoodData.get("/gdc/projects/#{pid}/model/view")
-      model = GoodData.poll_on_root(result, 'asyncTask') { |r| r['asyncTask']['link']['poll'] }
+      polling_url = result['asyncTask']['link']['poll']
+      model = GoodData.poll_on_code(polling_url)
       GoodData::Model::FromWire.from_wire(model)
     end
 
@@ -197,13 +204,10 @@ module GoodData
 
       result = GoodData.post("/gdc/md/#{obj_id}/maintenance/export", export)
       export_token = result['exportArtifact']['token']
-      status_url = result['exportArtifact']['status']['uri']
 
-      state = GoodData.get(status_url)['taskState']['status']
-      while state == 'RUNNING'
-        sleep 5
-        result = GoodData.get(status_url)
-        state = result['taskState']['status']
+      status_url = result['exportArtifact']['status']['uri']
+      GoodData.poll_on_response(status_url) do |body|
+        body['taskState']['status'] == 'RUNNING'
       end
 
       import = {
@@ -214,12 +218,10 @@ module GoodData
 
       result = GoodData.post("/gdc/md/#{new_project.obj_id}/maintenance/import", import)
       status_url = result['uri']
-      state = GoodData.get(status_url)['taskState']['status']
-      while state == 'RUNNING'
-        sleep 5
-        result = GoodData.get(status_url)
-        state = result['taskState']['status']
+      GoodData.poll_on_response(status_url) do |body|
+        body['taskState']['status'] == 'RUNNING'
       end
+
       new_project
     end
 
@@ -268,6 +270,14 @@ module GoodData
       end
     end
 
+    # Helper for getting facts of a project
+    #
+    # @param [String | Number | Object] Anything that you can pass to GoodData::Fact[id]
+    # @return [GoodData::Fact] fact instance or list
+    def fact(id)
+      GoodData::Fact[id, project: self]
+    end
+
     # Gets project role by its identifier
     #
     # @param [String] role_name Title of role to look for
@@ -476,9 +486,11 @@ module GoodData
       polling_url = result['partialMDArtifact']['status']['uri']
       token = result['partialMDArtifact']['token']
 
-      polling_result = GoodData.wait_for_polling_result(polling_url)
+      polling_result = GoodData.poll_on_response(polling_url) do |body|
+        body['wTaskStatus'] && body['wTaskStatus']['status'] == 'RUNNING'
+      end
 
-      fail 'Exporting objects failed' if polling_result['wTaskStatus']['status'] == 'ERROR'
+      fail 'Exporting objects failed' if polling_result['wTaskStatus'] && polling_result['wTaskStatus']['status'] == 'ERROR'
 
       import_payload = {
         :partialMDImport => {
@@ -490,7 +502,10 @@ module GoodData
 
       result = GoodData.post("#{target_project.md['maintenance']}/partialmdimport", import_payload)
       polling_url = result['uri']
-      polling_result = GoodData.wait_for_polling_result(polling_url)
+
+      GoodData.poll_on_response(polling_url) do |body|
+        body['wTaskStatus'] && body['wTaskStatus']['status'] == 'RUNNING'
+      end
 
       fail 'Exporting objects failed' if polling_result['wTaskStatus']['status'] == 'ERROR'
     end
@@ -576,12 +591,8 @@ module GoodData
     #
     # @return [Array<GoodData::Schedule>] List of schedules
     def schedules
-      res = []
       tmp = GoodData.get @json['project']['links']['schedules']
-      tmp['schedules']['items'].each do |schedule|
-        res << GoodData::Schedule.new(schedule)
-      end
-      res
+      tmp['schedules']['items'].map { |schedule| GoodData::Schedule.new(schedule) }
     end
 
     # Gets SLIs data
@@ -791,12 +802,9 @@ module GoodData
     def validate(filters = %w(ldm pdm metric_filter invalid_objects))
       response = GoodData.post "#{GoodData.project.md['validate-project']}", 'validateProject' => filters
       polling_link = response['asyncTask']['link']['poll']
-      polling_result = GoodData.get(polling_link)
-      while polling_result['wTaskStatus'] && polling_result['wTaskStatus']['status'] == 'RUNNING'
-        sleep(3)
-        polling_result = GoodData.get(polling_link)
+      GoodData.poll_on_response(polling_link) do |body|
+        body['wTaskStatus'] && body['wTaskStatus']['status'] == 'RUNNING'
       end
-      polling_result
     end
   end
 end