gooddata 0.5.16 → 0.6.0.pre2

data/lib/gooddata/commands/process.rb

@@ -0,0 +1,137 @@
+module GoodData::Command
+  class Process
+
+    def self.list(options={})
+      # with project usage
+      processes = GoodData::Process[:all]
+    end
+
+    def self.get(options={})
+      id = options[:process_id]
+      fail "Unspecified process id" if id.nil?
+      GoodData::Process[id]
+    end
+
+    def self.with_deploy(dir, options={}, &block) 
+      verbose = options[:verbose] || false
+      if block
+        begin
+          res = deploy_graph(dir, options)
+          block.call(res)
+        ensure
+          # self_link = res["process"]["links"]["self"]
+          # GoodData.delete(self_link)
+        end
+      else
+        deploy_graph(dir, options)
+      end
+    end
+
+    def self.deploy_graph(dir, options={}) 
+      dir = Pathname(dir) || fail("Directory is not specified")
+      fail "\"#{dir}\" is not a directory" unless dir.directory?
+      project_id = options[:project_id] || fail("Project Id has to be specified")
+      
+
+      type = options[:type] || fail("Type of deployment is not specified")
+      deploy_name = "AAAAA"
+      verbose = options[:verbose] || false
+      project_pid = options[:project_pid]
+      puts HighLine::color("Deploying #{dir}", HighLine::BOLD) if verbose
+      res = nil
+
+      Tempfile.open("deploy-graph-archive") do |temp|
+        
+        Zip::OutputStream.open(temp.path) do |zio|
+          Dir.glob(dir + "**/*") do |item|
+            puts "including #{item}" if verbose
+            unless File.directory?(item)
+              zio.put_next_entry(item)
+              zio.print IO.read(item)
+            end
+          end
+        end
+
+        GoodData.connection.upload(temp.path)
+        process_id = options[:process]
+        
+        data = {
+          :process => {
+            :name => deploy_name,
+            :path => "/uploads/#{File.basename(temp.path)}",
+            :type => type
+          }
+        }
+        res = if process_id.nil?
+          GoodData.post("/gdc/projects/#{project_pid}/dataload/processes", data)
+        else
+          GoodData.put("/gdc/projects/#{project_pid}/dataload/processes/#{process_id}", data)
+        end
+      end
+      puts HighLine::color("Deploy DONE #{dir}", HighLine::BOLD) if verbose
+      res
+    end
+
+    def self.execute_process(link, dir, options={})
+      dir = Pathname(dir)
+      type = :ruby
+      if type == :ruby 
+        result = GoodData.post(link, {
+          :execution => {
+           :graph => dir + "main.rb",
+           :params => {}  
+          }
+        })
+        begin
+          GoodData.poll(result, "executionTask")
+        rescue RestClient::RequestFailed => e
+
+        ensure
+          result = GoodData.get(result["executionTask"]["links"]["detail"])
+          if result["executionDetail"]["status"] == "ERROR"
+            fail "Runing process failed. You can look at a log here #{result["executionDetail"]["logFileName"]}"
+          end
+        end
+        result
+      else
+        result = GoodData.post(link, {
+          :execution => {
+           :graph => dir + "graphs/main.grf",
+           :params => {}  
+          }
+        })
+        begin
+          GoodData.poll(result, "executionTask")
+        rescue RestClient::RequestFailed => e
+
+        ensure
+          result = GoodData.get(result["executionTask"]["links"]["detail"])
+          if result["executionDetail"]["status"] == "ERROR"
+            fail "Runing process failed. You can look at a log here #{result["executionDetail"]["logFileName"]}"
+          end
+        end
+        result
+      end
+    end
+
+    def self.run(dir, options={})
+      email = options[:email]
+      verbose = options[:v]
+
+      dir = Pathname(dir)
+
+      with_deploy(dir, options.merge(:name => "Temporary deploy[#{dir}][#{options[:project_name]}]")) do |deploy_response|
+        puts HighLine::color("Executing", HighLine::BOLD) if verbose
+        # if email.nil?
+        #   result = execute_process(deploy_response["process"]["links"]["executions"], dir, options)
+        # else
+          # create_email_channel(options) do |channel_response|
+            # subscribe_on_finish(:success, channel_response, deploy_response, options)
+            result = execute_process(deploy_response["process"]["links"]["executions"], dir)
+          # end
+        # end
+      end
+    end
+
+  end
+end

data/lib/gooddata/commands/profile.rb

@@ -1,9 +1,9 @@
 module GoodData::Command
-  class Profile < Base
-    def show
-      connect
-      pp GoodData.profile.to_json
+  class Profile
+    class << self
+      def show
+        GoodData.profile.to_json
+      end
     end
-    alias :index :show
   end
 end

data/lib/gooddata/commands/projects.rb

@@ -1,51 +1,118 @@
-module GoodData
-  module Command
-    class Projects < Base
-      def list
-        connect
-        Project.all.each do |project|
-          puts "%s  %s" % [project.uri, project.title]
-        end
-      end
-      alias :index :list
+module GoodData::Command
+  class Projects
+
+    def self.list
+      GoodData::Project.all
+    end
 
-      def create
-        connect
+    def self.create(options={})
+      title = options[:title]
+      summary = options[:summary]
+      template = options[:template]
+      token = options[:token]
 
-        title = ask "Project name"
-        summary = ask "Project summary"
-        template = ask "Project template", :default => ''
+      GoodData::Project.create(:title => title, :summary => summary, :template => template, :auth_token => token)
+    end
 
-        project = Project.create :title => title, :summary => summary, :template => template
+    def self.show(id)
+      GoodData::Project[id]
+    end
 
-        puts "Project '#{project.title}' with id #{project.uri} created successfully!"
-      end
+    def self.clone(project_id, options)
+      with_data   = options[:with_data]
+      with_users  = options[:with_users]
+      title = options[:title]
+      
+      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"]
 
-      def show
-        id = args.shift rescue nil
-        raise(CommandFailed, "Specify the project key you wish to show.") if id.nil?
-        connect
-        pp Project[id].to_json
+      state = GoodData.get(status_url)["taskState"]["status"]
+      while state == "RUNNING"
+        sleep 5
+        result = GoodData.get(status_url) 
+        state = result["taskState"]["status"]
       end
 
-      def delete
-        raise(CommandFailed, "Specify the project key(s) for the project(s) you wish to delete.") if args.size == 0
-        connect
-        while args.size > 0
-          id = args.shift
-          project = Project[id]
-          ask "Do you want to delete the project '#{project.title}' with id #{project.uri}", :answers => %w(y n) do |answer|
-            case answer
-            when 'y' then
-              puts "Deleting #{project.title}..."
-              project.delete
-              puts "Project '#{project.title}' with id #{project.uri} deleted successfully!"
-            when 'n' then
-              puts "Aborting..."
-            end
-          end
-        end
+      old_project = GoodData::Project[project_id]
+      project_uri = self.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"]
       end
+      true
+    end
+
+    def self.delete(project_id)
+      p = GoodData::Project[project_id]
+      p.delete
     end
+
   end
 end
+
+# module GoodData
+#   module Command
+#     class Projects
+#       class << self
+#         def list
+#           Project.all
+#         end
+#         alias :index :list
+# 
+#       def create
+#         title = ask "Project name"
+#         summary = ask "Project summary"
+#         template = ask "Project template", :default => ''
+# 
+#         project = Project.create :title => title, :summary => summary, :template => template
+# 
+#         puts "Project '#{project.title}' with id #{project.uri} created successfully!"
+#       end
+# 
+#       def show
+#         id = args.shift rescue nil
+#         raise(CommandFailed, "Specify the project key you wish to show.") if id.nil?
+#         connect
+#         pp Project[id].to_json
+#       end
+# 
+#       def delete
+#         raise(CommandFailed, "Specify the project key(s) for the project(s) you wish to delete.") if args.size == 0
+#         connect
+#         while args.size > 0
+#           id = args.shift
+#           project = Project[id]
+#           ask "Do you want to delete the project '#{project.title}' with id #{project.uri}", :answers => %w(y n) do |answer|
+#             case answer
+#             when 'y' then
+#               puts "Deleting #{project.title}..."
+#               project.delete
+#               puts "Project '#{project.title}' with id #{project.uri} deleted successfully!"
+#             when 'n' then
+#               puts "Aborting..."
+#             end
+#           end
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/gooddata/commands/runners.rb

@@ -0,0 +1,37 @@
+module GoodData::Command
+  class Runners
+
+    def self.run_ruby(brick_dir, options={})
+      pid = options[:project]
+      fail "You have to specify a project ID" if pid.nil?
+      fail "You have to specify directory of the brick ran" if brick_dir.nil?
+
+      params = if options[:params]
+        JSON.parse(File.read(options[:params]), :symbolize_names => true)
+      else
+        {}
+      end
+
+      GoodData.connection.connect!
+      sst = GoodData.connection.cookies[:cookies]["GDCAuthSST"]
+      
+      logger_stream = STDOUT
+script_body = <<-script_body
+      require 'fileutils'
+      FileUtils::cd(\"#{brick_dir}\") do\
+        require 'bundler/setup'
+        eval(File.read(\"main.rb\")).call({
+          :gdc_sst => \"#{sst}\",
+          :gdc_project => \"#{pid}\"
+        }.merge(#{params}))
+      end
+script_body
+
+
+      Bundler.with_clean_env do
+        system("ruby", "-e", script_body)  
+      end
+    end
+
+  end
+end

data/lib/gooddata/commands/scaffold.rb

@@ -0,0 +1,30 @@
+module GoodData::Command
+  class Scaffold
+    class << self
+
+      def brick(name)
+        
+        require 'erubis'
+        require 'fileutils'
+        
+        templates_path = Pathname(__FILE__) + "../../../templates"
+        
+        FileUtils.mkdir(name)
+        FileUtils.cd(name) do
+          input = File.read(templates_path + 'bricks/brick.rb.erb')
+          eruby = Erubis::Eruby.new(input)
+          File.open("brick.rb", 'w') do |f|
+            f.write(eruby.result())
+          end
+          
+          input = File.read(templates_path + 'bricks/main.rb.erb')
+          eruby = Erubis::Eruby.new(input)
+          File.open("main.rb", 'w') do |f|
+            f.write(eruby.result())
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/gooddata/connection.rb

@@ -34,7 +34,7 @@ module GoodData
     TOKEN_PATH = '/gdc/account/token'
     STAGE_PATH = '/uploads/'
 
-    attr_reader(:auth_token)
+    attr_reader(:auth_token, :url)
     attr_accessor :status
 
 
@@ -70,22 +70,16 @@ module GoodData
     #
     # * +username+ - The GoodData account username
     # * +password+ - The GoodData account password
-    def initialize(username, password, url = nil, options = {})
+    def initialize(username, password, options = {})
       @status     = :not_connected
       @username   = username
       @password   = password
-      @url        = url || DEFAULT_URL
+      @url        = options[:server] || DEFAULT_URL
       @auth_token = options.delete(:auth_token)
       @options    = options
 
-      @server = RestClient::Resource.new @url,
-        :timeout => @options[:timeout],
-        :headers => {
-          :content_type => :json,
-          :accept => [ :json, :zip ],
-          :user_agent => GoodData.gem_version_string,
-        }
-
+      @server = create_server_connection(@url, @options)
+      
     end
 
     # Returns the user JSON object of the currently logged in GoodData user account.
@@ -106,7 +100,7 @@ module GoodData
     #
     #   Connection.new(username, password).get '/gdc/projects'
     def get(path, options = {})
-      GoodData.logger.debug "GET #{path}"
+      GoodData.logger.debug "GET #{@server}#{path}"
       ensure_connection
       b = Proc.new { @server[path].get cookies }
       process_response(options, &b)
@@ -126,7 +120,7 @@ module GoodData
     #   Connection.new(username, password).post '/gdc/projects', { ... }
     def post(path, data, options = {})
       payload = data.is_a?(Hash) ? data.to_json : data
-      GoodData.logger.debug "POST #{path}, payload: #{payload}"
+      GoodData.logger.debug "POST #{@server}#{path}, payload: #{payload}"
       ensure_connection
       b = Proc.new { @server[path].post payload, cookies }
       process_response(options, &b)
@@ -146,7 +140,7 @@ module GoodData
     #   Connection.new(username, password).put '/gdc/projects', { ... }
     def put(path, data, options = {})
       payload = data.is_a?(Hash) ? data.to_json : data
-      GoodData.logger.debug "PUT #{path}, payload: #{payload}"
+      GoodData.logger.debug "PUT #{@server}#{path}, payload: #{payload}"
       ensure_connection
       b = Proc.new { @server[path].put payload, cookies }
       process_response(options, &b)
@@ -164,7 +158,7 @@ module GoodData
     #
     #   Connection.new(username, password).delete '/gdc/project/1'
     def delete(path, options = {})
-      GoodData.logger.debug "DELETE #{path}"
+      GoodData.logger.debug "DELETE #{@server}#{path}"
       ensure_connection
       b = Proc.new { @server[path].delete cookies }
       process_response(options, &b)
@@ -187,6 +181,11 @@ module GoodData
       @status == :logged_in
     end
 
+    def url=(url=nil)
+      @url = url || DEFAULT_URL
+      @server = create_server_connection(@url, @options)
+    end
+
     # The connection will automatically be established once it's needed, which it
     # usually is when either the user, get, post or delete method is called. If you
     # want to force a connection (or a re-connect) you can use this method.
@@ -197,11 +196,11 @@ module GoodData
     # Uploads a file to GoodData server
     # /uploads/ resources are special in that they use a different
     # host and a basic authentication.
-    def upload(file, dir = nil)
+    def upload(file, dir = nil, options={})
       ensure_connection
       # We should have followed a link. If it was correct.
+      
       stage_url = @options[:webdav_server] || @url.sub(/\./, '-di.')
-
       # Make a directory, if needed
       if dir then
         url = stage_url + STAGE_PATH + dir + '/'
@@ -239,17 +238,20 @@ module GoodData
         dir = "."
       end
 
+      payload = options[:stream] ? "file" : File.read(file)
+      filename = options[:filename] || options[:stream] ? "randome-filename.txt" : File.basename(file)
+
       # Upload the file
       RestClient::Request.execute(
         :method => :put,
-        :url => stage_url + STAGE_PATH + dir + '/' + File.basename(file),
+        :url => stage_url + STAGE_PATH + dir + '/' + filename,
         :user => @username,
         :password => @password,
         :timeout => @options[:timeout],
         :headers => {
           :user_agent => GoodData.gem_version_string,
         },
-        :payload => File.read(file)
+        :payload => payload
       )
     end
 
@@ -271,6 +273,16 @@ module GoodData
 
     private
 
+    def create_server_connection(url, options)
+      RestClient::Resource.new url,
+        :timeout => options[:timeout],
+        :headers => {
+          :content_type => :json,
+          :accept => [ :json, :zip ],
+          :user_agent => GoodData.gem_version_string,
+        }
+    end
+
     def ensure_connection
       connect if @status == :not_connected
     end