gd_bam 0.0.1

data/lib/runtime.rb

@@ -0,0 +1,517 @@
+require 'nodes/clover_gen'
+require 'nodes/nodes'
+require 'nodes/dependency'
+require 'dsl/project_dsl'
+require 'pathname'
+require 'json'
+require 'builder'
+require 'erubis'
+require 'salesforce'
+require 'active_support/time'
+require 'es'
+require 'gooddata'
+require 'logger'
+require 'highline'
+
+module GoodData
+
+  module CloverGenerator
+
+    GENERATOR_ROOT = Pathname(__FILE__).expand_path.dirname
+    BAM_ROOT = GENERATOR_ROOT.parent
+
+    BAM_DEFINED_GRAPHS_ROOT = GENERATOR_ROOT + "graphs"
+    REPO_ROOT = GENERATOR_ROOT + "repo"
+    TEMPLATE_ROOT = BAM_ROOT + "templates"
+
+    DEFINITION_ROOT = Pathname.new(Dir.pwd)
+    USER_DEFINED_GRAPHS_ROOT = DEFINITION_ROOT + "local_graphs"
+
+    CLOVER_PROJECT_ROOT = DEFINITION_ROOT + "clover-project"
+    CLOVER_DOWNLOADERS_ROOT = DEFINITION_ROOT + "downloader-project"
+
+    PROJECT_GRAPHS_ROOT = "graphs"
+    PROJECT_METADATA_ROOT = "metadata"
+    PROJECT_DATA_ROOT = "data"
+
+    PARAM_FILE = DEFINITION_ROOT + 'params.json'  
+    FLOWS_ROOT = DEFINITION_ROOT + "flows"
+    PARAMS = File.exist?(PARAM_FILE) ? JSON.parse(File.read(PARAM_FILE), :symbolize_names => true) : {}
+
+    PARAMS = {:additional_params => nil}.merge(PARAMS)
+
+    include GoodData::CloverGenerator::Dependency
+
+
+    def self.render_template(template, params, options={})
+      to_file = options[:to_file]
+      root = options[:root] || TEMPLATE_ROOT
+      t = Pathname(template)
+      output = Erubis::Eruby.new(File.read(root + t)).result(params)
+      if to_file.nil?
+        output
+      else
+        File.open(to_file, 'w') {|f| f.write(output)}
+      end
+    end
+
+    def self.setup_clover_project(base)
+      [PROJECT_GRAPHS_ROOT, PROJECT_METADATA_ROOT, PROJECT_DATA_ROOT].each do |dir|
+        FileUtils::mkdir_p base + dir
+      end
+      FileUtils::touch(base + 'params.txt')
+      render_template("project.erb", PARAMS, :to_file => base + '.project')
+      render_template("workspace.prm.erb", PARAMS, :to_file => base + 'workspace.prm')
+    end
+
+    def self.setup_bash_structure(name)
+      fail "Directory \"#{name}\" already exists. Please remove it if you want to move forward." if File.exist?(name)
+      FileUtils::mkdir_p name
+      FileUtils::cd(name) do
+        render_template("params.json.erb", PARAMS, :to_file => 'params.json')
+        ['flows', 'sinks', 'taps'].each do |dir|
+          FileUtils::mkdir_p dir
+        end
+
+        setup_flow('user')
+        # render_template("flow.rb.erb", PARAMS, :to_file => 'flows/flow_example.rb')
+        render_template("source.json.erb", PARAMS, :to_file => 'taps/source_example.json')
+        render_template("dataset.json.erb", PARAMS, :to_file => 'sinks/dataset_example.json')
+      end
+
+    end
+
+    def self.setup_flow(name)
+      render_template("flow.rb.erb", {:flow_name => name}, :to_file => "flows/#{name}.rb")
+    end
+
+    def self.setup_tap(name)
+      render_template("tap.json.erb", {:tap_name => name}, :to_file => "taps/#{name}.json")
+    end
+
+    def self.clobber_clover_project()
+      FileUtils::rm_rf(CLOVER_PROJECT_ROOT)
+    end
+
+    def self.clobber_downloader_project()
+      FileUtils::rm_rf(CLOVER_DOWNLOADERS_ROOT)
+    end
+
+    def self.build_project()
+      p = GoodData::CloverGenerator::DSL.project do |p|
+        project_name("Goodsales for ABCD")
+
+        use_dims ["GoodSales/opportunity", "GoodSales/user"]
+        use_usecase("GoodSales/quota_attainment")
+      end
+
+      repos = GoodData::CloverGenerator::Repo.load(REPO_ROOT).map {|config| N.new(config)}
+      p.run(repos)
+      p
+    end
+
+    def self.validate_datasets
+      project = build_project
+      datasets = project.get_datasets
+      GoodData.connect(PARAMS[:gd_login], PARAMS[:gd_pass])
+      GoodData.project = PARAMS[:project_pid]
+      gd_datasets = GoodData.get("/gdc/md/#{PARAMS[:project_pid]}/query/datasets")['query']['entries'].map {|m| GoodData.get(m['link'])}
+      report1 = GoodData::CloverGenerator::validate_gd_datasets_metadata(datasets, gd_datasets)
+      report2 = GoodData::CloverGenerator::validate_gd_datasets(datasets, gd_datasets)
+      report1.merge(report2)
+    end
+
+    def self.procs_list(options={})
+      project = build_project
+      datasets = project.get_datasets
+      GoodData.connect(PARAMS[:gd_login], PARAMS[:gd_pass])
+      procs = GoodData.get("/gdc/projects/#{PARAMS[:project_pid]}/dataload/processes")
+      procs["processes"]["items"].map {|p| [p["process"]["name"], p["process"]["links"]["self"]]}
+    end
+
+    def self.validate_taps
+      project = build_project
+      sources = project.get_sources
+      client = get_sf_client(PARAMS)
+      sf_sources = sources.find_all {|tap| tap[:source] == "salesforce"}
+      report = GoodData::CloverGenerator::validate_sf_metadata(client, sf_sources)
+      pp report
+    end
+
+    def self.taps_generate_docs
+      project = build_project
+      sources = project.get_sources
+
+      
+      taps = ""
+      sources.each do |source|
+        x = GoodData::CloverGenerator.transformation_acts_as(source)
+        taps += "#####{source[:object]}"
+        taps += "\n"
+        x.each do |field|
+          taps += "* #{field[0]} -> #{field[1]}"
+          taps += "\n"
+        end
+      end
+      render_template("README.md.erb", PARAMS.merge(:taps => taps), :to_file => 'README.md', :root => DEFINITION_ROOT)
+    end
+
+    def self.model_sync(options)
+      dry_run = options[:dry]
+      project = build_project
+      datasets = project.get_datasets
+      datasets.each do |ds|
+        dataset_path = "cl_file_#{ds[:id]}"
+        File.open(dataset_path, "w") do |temp|
+          builder = Builder::XmlMarkup.new(:target=>temp, :indent=>2)
+          builder.schema do |builder|
+            builder.name(ds[:gd_name])
+            builder.title(ds[:gd_name])
+            builder.columns do |b|
+              ds[:fields].each do |f|
+                builder.column do |builder|
+                  builder.title(f[:name])
+                  builder.ldmType(f[:type].upcase)
+                  builder.reference(f[:for]) if f.has_key?(:for)
+                  builder.reference(f[:ref]) if f.has_key?(:ref)
+                  builder.schemaReference(f[:schema]) if f.has_key?(:schema)
+                  if f[:type] == "date"
+                    builder.schemaReference("#{f[:dd]}")
+                    builder.name("#{f[:name]}")
+                  else
+                    builder.name(f[:name] || f[:ref])
+                  end
+                end
+              end
+            end
+          end
+        end
+        template_name = dry_run ? "update_dataset_dry.script.erb" : "update_dataset.script.erb"
+        render_template(template_name, PARAMS.merge({"config_file" => dataset_path}), :to_file => 'update_dataset.script')
+        puts "Generate #{ds[:id]}"
+        system("~/Downloads/gooddata-cli-1.2.65/bin/gdi.sh update_dataset.script --username #{PARAMS[:gd_login]} --password #{PARAMS[:gd_pass]}")
+        File.delete(dataset_path)
+      end
+    end
+
+    def self.generate_downloaders(options={})
+      setup_clover_project(CLOVER_DOWNLOADERS_ROOT)
+      project = build_project
+      sources = project.get_sources
+      sf_sources = sources.find_all {|tap| tap[:source] == "salesforce" && tap[:incremental] == true}
+      create_incremental_downloader_run_graph(CLOVER_DOWNLOADERS_ROOT + PROJECT_GRAPHS_ROOT + "main.grf", sf_sources)
+      GoodData::CloverGenerator::create_incremental_downloading_graph(CLOVER_DOWNLOADERS_ROOT + PROJECT_GRAPHS_ROOT + "incremental.grf", sf_sources, {
+        :password => PARAMS[:sf_password],
+        :token    => PARAMS[:sf_token],
+        :login    => PARAMS[:sf_login],
+        :sf_server => PARAMS[:sf_server],
+        :s3_backup => false
+      })
+    end
+
+
+    def self.execute_process(link, dir)
+      result = GoodData.post(link, {
+        :graphExecution => {
+         :graph => "./#{dir}/graphs/main.grf",
+         :params => {}  
+        }
+      })
+      GoodData.poll(result, "cloverExecutionTask")
+    end
+
+    def self.connect_to_gd
+        # GoodData.logger = Logger.new(STDOUT)
+        GoodData.connect(PARAMS[:gd_login], PARAMS[:gd_pass])
+        GoodData.project = PARAMS[:project_pid]
+    end
+
+    def self.create_email_channel(&block)
+      data = {
+        :channelConfiguration => {
+          :configuration => {
+            :emailConfiguration => {
+              :to => "svarovsky@gooddata.com"
+            }
+          },
+          :meta => {
+            :title => "temporary email channel"
+          }
+        }
+      }
+      profile_id = GoodData.connection.user["profile"].split("/").last
+      res = GoodData.post("/gdc/account/profile/#{profile_id}/channelConfigurations", data)
+      self_link = res["channelConfiguration"]["meta"]["uri"]
+      if block
+        begin
+          block.call(res)
+        ensure
+          GoodData.delete(self_link)
+        end
+      else
+        res
+      end
+    end
+
+    def self.deploy_graph(dir, options={}) 
+      deploy_name = options[:name]
+      verbose = options[:verbose] || false
+      puts HighLine::color("Deploying #{dir}", HighLine::BOLD) if verbose
+
+      Tempfile.open("deploy-graph-archive") do |temp|
+        Zip::ZipOutputStream.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 = {
+            :cloverTransformation => {
+              :name => deploy_name || "#{PARAMS[:project_name]}",
+              :path => "/uploads/#{File.basename(temp.path)}"
+            }
+          }
+        res = if process_id.nil?
+          GoodData.post("/gdc/projects/#{PARAMS[:project_pid]}/etl/clover/transformations", data)
+        else
+          GoodData.put("/gdc/projects/#{PARAMS[:project_pid]}/etl/clover/transformations/#{process_id}", data)
+        end
+      end
+      puts HighLine::color("Deploy DONE #{dir}", HighLine::BOLD) if verbose
+    end
+
+    def self.deploy(dir, options={}, &block) 
+      verbose = options[:verbose] || false
+
+      if block
+        begin
+          res = deploy_graph(dir, options)
+          block.call(res)
+        ensure
+          self_link = res["cloverTransformation"]["links"]["self"]
+          GoodData.delete(self_link)
+        end
+      else
+        deploy_graph(dir, options)
+      end
+    end
+
+
+    def self.run(options)
+
+      only_flow = options[:only]
+      setup_clover_project(CLOVER_PROJECT_ROOT)
+      p = build_project
+      sources   = p.get_sources
+      datasets  = p.get_datasets
+
+      flows = []
+      FileUtils::cd FLOWS_ROOT do
+        flows_sources = Dir.glob("*.rb")
+        flows = flows_sources.map do |f|
+          instance_eval(File.read(f))
+        end
+      end
+
+      flows = flows.find_all {|flow| flow && flow.name == only_flow} unless only_flow.nil? || only_flow.empty?
+      super_flow = []
+      FileUtils::cd CLOVER_PROJECT_ROOT do
+
+        flows.each do |f|
+
+          current_metadata = {}
+          steps_to_be_wrapped = []
+          flow_sources = []
+          if f.nil?
+            puts "Flow skipped"
+            next
+          end
+          name = f.name
+          step_no = 0
+
+          begin
+            f.steps.each_with_index do |s, i|
+
+              if s[:type] == :tap
+                source_name = s[:source_name] || f.name
+                source = sources.find do |source|
+                  source[:id] == source_name
+                end
+
+                fail "Source \"#{source_name}\" was not found" if source.nil?
+
+                flow_sources << source
+
+                dataset_name = source[:dataset] || source[:id]
+
+                current_metadata[source_name] = GoodData::CloverGenerator::create_metadata(source)
+                graph_name = "graphs/#{dataset_name}_#{source[:source]}_#{source[:type]}.grf"
+                steps_to_be_wrapped << {
+                  :name => "#{source_name}_download",
+                  :file => graph_name,
+                  :flow => source_name
+                }
+
+                if source[:incremental] == true
+                  current_metadata[source_name] = GoodData::CloverGenerator::DSL::Metadata.new(current_metadata[source_name]).change do |m|
+                    m.remove("timestamp")
+                  end.to_hash
+                  
+                  GoodData::CloverGenerator::create_es_downloading_graph(graph_name, [source], {
+                    :metadata => current_metadata[source_name],
+                    :s3_backup => false
+                  })
+                else
+                  GoodData::CloverGenerator::create_sf_downloading_graph(graph_name, [source], {
+                    :password => PARAMS[:sf_password],
+                    :token    => PARAMS[:sf_token],
+                    :login    => PARAMS[:sf_login],
+                    :sf_server => PARAMS[:sf_server],
+                    :metadata => current_metadata[source_name],
+                    :s3_backup => false
+                  })
+                end
+
+                step_no += 1
+              elsif s[:type] == :upload
+                source_name = s[:id] || f.name
+                dataset = datasets.find {|d| d[:id] == source_name}
+                
+                fail "Dataset \"#{source_name}\" was not found" if dataset.nil?
+                fail "Sink needs to have id defined" if dataset[:id].nil?
+                
+                unless current_metadata.has_key?(source_name)
+                  fail("Source #{source_name} was not found in current metadata") 
+                end
+                fail "Dataset \"#{f.name}\" was not found" if dataset.nil?
+                metadata = current_metadata[source_name]
+
+                graph_name = "graphs/#{dataset[:id]}_#{dataset[:type]}.grf"
+                steps_to_be_wrapped << {
+                  :name => "#{name}_upload",
+                  :file => graph_name,
+                  :flow => source_name
+                }
+
+                GoodData::CloverGenerator::create_uploading_graph(graph_name, {
+                  :datasets => dataset,
+                  :metadata => current_metadata[source_name]
+                })
+                step_no += 1
+              elsif s[:type] == :user_provided
+                # check that what is getting in a step is check
+                s[:metadata_block] && s[:metadata_block].each do |val|
+                  name = val[:name]
+                  next if(name.nil?)
+                  sources_names = flow_sources.map {|flow_source| flow_source[:id]}
+                  included_in_flow = sources_names.include?(name)
+                  unless included_in_flow
+                  #   binding.pry
+                  #   fail "Metadata \"#{name}\" is not in the defined by any source" 
+                  end
+                end
+                graph_name = s[:graph]
+                graph_filename = "#{s[:graph]}.grf"
+                
+                if File.exist?(USER_DEFINED_GRAPHS_ROOT + graph_filename)
+                  FileUtils::cp(USER_DEFINED_GRAPHS_ROOT + graph_filename, CLOVER_PROJECT_ROOT + PROJECT_GRAPHS_ROOT)
+                elsif File.exist?(BAM_DEFINED_GRAPHS_ROOT + graph_filename)
+                  FileUtils::cp(BAM_DEFINED_GRAPHS_ROOT + graph_filename, CLOVER_PROJECT_ROOT + PROJECT_GRAPHS_ROOT)
+                else
+                  fail("The graph \"#{graph_filename}\" was not found in any location (local, global)")
+                end
+                graph_filename = "graphs/#{graph_filename}"
+
+                step_no += 1
+                s[:metadata_block] && s[:metadata_block].each_with_index do |metadata, i|
+                  j = i+1
+                  bl = metadata[:block]
+                  name = metadata[:name] || f.name
+                  as = metadata[:out_as]
+                  FileUtils::mkdir_p("metadata/#{f.name}/#{graph_name}")
+
+                  input_meta = current_metadata[name].clone
+
+                  input_meta[:name] = "in_#{j}"
+                  GoodData::CloverGenerator::save_metadata("metadata/#{f.name}/#{graph_name}/#{j}_in.xml", input_meta)
+                  m = GoodData::CloverGenerator::DSL::Metadata.new(current_metadata[name])
+                  new_m = (bl && bl.call(m)) || current_metadata[name]
+
+                  current_metadata[name] = new_m
+                  unless as.nil?
+                    as_metadata = new_m.clone
+                    as_metadata[:name] = as
+                    current_metadata[as] = as_metadata 
+                  end
+
+                  output_meta = current_metadata[name].clone
+                  output_meta[:name] = "out_#{j}"
+                  GoodData::CloverGenerator::save_metadata("metadata/#{f.name}/#{graph_name}/#{j}_out.xml", output_meta)
+
+                  GoodData::CloverGenerator::create_moving_graph("graphs/#{f.name}_#{graph_name}_move_in_#{j}.grf", {
+                    :source => "${DATA}/#{name}.csv",
+                    :target => "${DATA}/#{j}_in.csv",
+                    :operation => "MOVE"
+                  })
+
+                  steps_to_be_wrapped << {
+                    :name => "graphs/#{f.name}_#{graph_name}_move_in_#{j}.grf",
+                    :file => "graphs/#{f.name}_#{graph_name}_move_in_#{j}.grf",
+                    :flow => "kopirujeme"
+                  }
+                end
+
+                steps_to_be_wrapped << {
+                  :name => graph_name,
+                  :file => graph_filename,
+                  :flow => f.name
+                }
+                output_id = if s[:metadata_block] && s[:metadata_block].any? {|metadata| metadata[:out_as]}
+                  s[:metadata_block].find {|metadata| metadata[:out_as]}[:out_as]
+                end
+
+                output_id = s[:metadata_block].first[:name] if output_id.nil? && s[:metadata_block].length == 1
+
+                GoodData::CloverGenerator::create_moving_graph("graphs/#{f.name}_#{graph_name}_move_out.grf", {
+                  :source => "${DATA}/out.csv",
+                  :target => "${DATA}/#{output_id}.csv",
+                  :operation => "MOVE"
+                })
+
+                steps_to_be_wrapped << {
+                  :name => "graphs/#{f.name}_#{graph_name}_move_out.grf",
+                  :file => "graphs/#{f.name}_#{graph_name}_move_out.grf",
+                  :flow => "kopirujeme"
+                }
+                
+              end
+            end
+          rescue GoodData::CloverGenerator::DSL::RemoveMetadataFieldError => e 
+            puts "Removing field \"#{e.field}\" from metadata \"#{e.metadata.name}\" in Flow \"#{f.name}\" there was a roblem with step X."
+          end
+
+          GoodData::CloverGenerator::create_run_graph("graphs/#{f.name}_main.grf", {
+            :subgraphs => steps_to_be_wrapped
+          })
+          super_flow << {
+            :name => name,
+            :file => "graphs/#{f.name}_main.grf",
+            :flow => f.name
+          }
+        end
+
+        GoodData::CloverGenerator::create_run_graph("graphs/main.grf", {
+          :subgraphs => super_flow
+        })
+      end
+    end
+  end
+end

data/templates/dataset.json.erb

@@ -0,0 +1,13 @@
+{
+   "type"     : "dataset"
+  ,"id"       : "user"
+  ,"gd_name"  : "user"
+  ,"fields"   : [
+    {
+      "name" : "Id"
+    },
+    {
+      "name" : "Name"
+    }
+  ]
+}

data/templates/flow.rb.erb

@@ -0,0 +1,12 @@
+GoodData::CloverGenerator::DSL::flow("<%= flow_name %>") do |f|
+  tap(:id => "user")
+
+  graph("process_owner")
+  metadata("user") do |m|
+    m.remove("FirstName")
+    m.remove("LastName")
+    m.add(:name => "Name", :type => "string")
+  end
+
+  sink(:id => "user")
+end

data/templates/params.json.erb

@@ -0,0 +1,7 @@
+{
+  "project_name"  : "",
+  "project_pid"   : "",
+  "sf_password"   : "",
+  "sf_token"      : "",
+  "sf_login"      : ""
+}

data/templates/project.erb

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+        <name><%= project_name%></name>
+        <comment></comment>
+        <projects>
+        </projects>
+        <buildSpec>
+                <buildCommand>
+                        <name>org.eclipse.jdt.core.javabuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+        </buildSpec>
+        <natures>
+                <nature>com.cloveretl.gui.runtime.CloudConnect</nature>
+                <nature>org.eclipse.jdt.core.javanature</nature>
+        </natures>
+</projectDescription>

data/templates/source.json.erb

@@ -0,0 +1,22 @@
+{
+   "source" : "salesforce"
+  ,"object" : "User"
+  ,"id"     : "user"
+  ,"fields" : [
+    {
+      "name" : "Id"
+    },
+    {
+      "name" : "FirstName"
+    },
+    {
+      "name" : "LastName"
+    },
+    {
+      "name" : "Region"
+    },
+    {
+      "name" : "Department"
+    }
+  ]
+}

data/templates/tap.json.erb

@@ -0,0 +1,16 @@
+{
+  "type" : "tap"
+  ,"source" : "salesforce"
+  ,"object" : "<%= tap_name %>"
+  ,"id" : "<%= tap_name %>"
+  ,"incremental" : false
+  ,"fields" : [
+		{
+			"name" : "Id"
+		},
+		{
+			"name" : "Name", "acts_as": ["Name_alias"]
+		}
+	]
+	// ,"limit": "10"
+}

data/templates/update_dataset.script.erb

@@ -0,0 +1,4 @@
+OpenProject(id="<%= project_pid %>");
+UseCsv(csvDataFile="xy", configFile="<%= config_file %>", hasHeader="true", separator = ",");
+GenerateUpdateMaql(maqlFile="<%= config_file %>.maql");
+ExecuteMaql(maqlFile="<%= config_file %>.maql");

data/templates/update_dataset_dry.script.erb

@@ -0,0 +1,3 @@
+OpenProject(id="<%= project_pid %>");
+UseCsv(csvDataFile="xy", configFile="<%= config_file %>", hasHeader="true", separator = ",");
+GenerateUpdateMaql(maqlFile="<%= config_file %>.maql");

data/templates/workspace.prm.erb

@@ -0,0 +1,25 @@
+#(Please use slash '/' character as a path delimiter in all path specifications, e.g., C:/Users/username/workspace/project)
+
+PROJECT= .
+DATA=${PROJECT}/data
+DATA_SOURCE=${PROJECT}/data/source
+DATA_TRANSFORM=${PROJECT}/data/transform
+DATA_GOODDATA=${PROJECT}/data/gooddata
+DATA_TMP=${PROJECT}/data/tmp
+GRAPH=${PROJECT}/graph
+META=${PROJECT}/meta
+TRANS=${PROJECT}/trans
+MODEL=${PROJECT}/model
+
+
+# GoodData working project
+# GDC_PROJECT_ID identifies the GoodData working project. Transformed data will be uploaded into the datasets of the GoodData working project.
+#   The data model information necessary for transformation definition is also obtained from this project.
+# You can find the ID of a project in the project context menu in Server Explorer.
+GDC_PROJECT_ID=<%= project_pid %>
+
+<% if additional_params %>
+	<% additional_params.each_pair do |key, val| %>
+<%= "#{key}=#{val}" %>
+	<% end %>
+<% end %>