gd_bam 0.1.0 → 0.1.1

data/lib/runtime.rb.orig

@@ -0,0 +1,748 @@
+require 'nodes/clover_gen'
+require 'nodes/dependency'
+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"
+    CONTRACT_PROJECT_ROOT = DEFINITION_ROOT + "contract-project"
+
+    PROJECT_GRAPHS_ROOT = "graphs"
+    PROJECT_METADATA_ROOT = "metadata"
+    PROJECT_DATA_ROOT = "data"
+
+    PARAM_FILE = DEFINITION_ROOT + 'params.json'  
+    FLOWS_ROOT = DEFINITION_ROOT + "flows"
+    USER_DEFINED_PARAMS = File.exist?(PARAM_FILE) ? JSON.parse(File.read(PARAM_FILE), :symbolize_names => true) : {}
+
+    PARAMS = {:additional_params => {}}.merge(USER_DEFINED_PARAMS).merge(USER_DEFINED_PARAMS[:additional_params] || {})
+
+    # TODO: REMOVE WHEN WEBDAV cann use SST
+    PARAMS[:additional_params][:GD_LOGIN] = PARAMS[:gd_login]
+    PARAMS[:additional_params][:GD_PASSWORD] = PARAMS[:gd_pass]
+    PARAMS[:additional_params][:GDC_WEBDAV_HOST] = PARAMS[:web_dav_host] || "secure-di.gooddata.com"
+
+<<<<<<< Updated upstream
+=======
+
+    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.set_up_debug(project, flow, graph)
+      fail "Project \"#{project}\" was not found" unless File.exist?(project)
+      fail "Project \"#{project}\" is not a directory" unless File.directory?(project)
+      # :TODO make the proram really check there is a flow and a graph etc before writing to the file
+      project = Pathname(project)
+      File.open(project + 'params.prm', 'w') do |f|
+        f << "FLOW=#{flow}\n"
+        f << "NAME=#{graph}\n"
+      end
+    end
+
+    def self.setup_clover_project(base, options={})
+
+      name = options[:name] || PARAMS[:project_name]
+
+      [PROJECT_GRAPHS_ROOT, PROJECT_METADATA_ROOT, PROJECT_DATA_ROOT].each do |dir|
+        FileUtils::mkdir_p base + dir
+      end
+      File.open(base + 'params.prm', 'w') do |f|
+        f << "TRASH=0"
+      end
+      render_template("project.erb", PARAMS.merge(:project_name => name), :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"}
+      GoodData::CloverGenerator::validate_sf_metadata(client, sf_sources)
+    end
+
+    def self.sf_jack_in
+      client = get_sf_client(PARAMS)
+      client.pry
+    end
+
+    def self.generate_docs
+      project = build_project
+      sources = project.get_sources
+      datasets = project.get_datasets
+
+      taps = ""
+      sources.each do |source|
+        taps += "####{source[:object]}"
+        taps += "\n"
+        source[:fields].each do |f|
+          if f[:acts_as]
+            taps += "    #{f[:name]} -> #{f[:acts_as].join(", ")}"
+          else
+            taps += "    #{f[:name]}"
+          end
+          taps += "\n"
+        end
+
+        taps += "\n"
+      end
+
+      sinks = ""
+      datasets.each do |sink|
+        name = sink[:gd_name] || sink[:id]
+        sinks += "####{name}\n"
+        sink[:fields].each do |field|
+          name = field[:name] || "#{field[:schema]}:#{field[:ref]}"
+          type = field[:type]
+          sinks += "    #{type.upcase} #{field[:meta]} => #{name}\n"
+        end
+        sinks += "\n"
+
+      end
+
+
+      render_template("README.md.erb", PARAMS.merge(:taps => taps, :sinks => sinks), :to_file => 'README.md', :root => DEFINITION_ROOT)
+    end
+
+    def self.model_sync(options)
+      dry_run = options[:dry]
+      project = build_project
+      datasets = project.get_datasets
+      model_update_dir = Pathname('model_update')
+      cl_home = ENV['CL_HOME'] || PARAMS['CL_HOME'] || fail("Home of cl tool cannot be found. Either set up CL_HOME in your env with 'export CL_HOME=path/to/cl or set it up in your params.json. Point to the directory of CL not to the bin dir.'")
+      cl_home = Pathname(cl_home) + 'bin/gdi.sh'
+
+      FileUtils::mkdir_p(model_update_dir)
+      File.open(model_update_dir + 'dummy', 'w')
+      FileUtils::cd(model_update_dir) do
+        datasets.each do |ds|
+          dataset_path = Pathname("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.expand_path}), :to_file => 'update_dataset.script')
+          puts "Generate #{ds[:id]}"
+
+          system("#{cl_home} update_dataset.script --username #{PARAMS[:gd_login]} --password #{PARAMS[:gd_pass]}")
+          File.delete(dataset_path)        
+        end
+      end
+      FileUtils::rm_rf(model_update_dir)
+    end
+
+    def self.generate_downloaders(options={})
+      setup_clover_project(CLOVER_DOWNLOADERS_ROOT, :name => "downloaders-#{PARAMS[:project_name]}")
+      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)
+      s3_backup = PARAMS[:S3_SECRET_ACCESS_KEY] && PARAMS[:S3_ACCESS_KEY_ID] && PARAMS[:S3_BUCKETNAME]
+
+      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 => s3_backup
+      })
+    end
+
+
+    def self.run(dir, options={})
+      email = options[:email]
+      verbose = options[:v]
+
+      dir = Pathname(dir)
+
+      GoodData::CloverGenerator.deploy(dir, options.merge(:name => "Temporary deploy[#{dir}][#{PARAMS[:project_name]}]")) do |deploy_response|
+        puts HighLine::color("Executing", HighLine::BOLD) if verbose
+        if email.nil?
+          result = GoodData::CloverGenerator.execute_process(deploy_response["process"]["links"]["executions"], dir)
+        else
+          GoodData::CloverGenerator.create_email_channel(options) do |channel_response|
+            GoodData::CloverGenerator.subscribe_on_finish(:success, channel_response, deploy_response, options)
+            result = GoodData::CloverGenerator.execute_process(deploy_response["process"]["links"]["executions"], dir)
+          end
+        end
+      end
+    end
+
+    def self.execute_process(link, dir)
+      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
+
+    def self.connect_to_gd(options={})
+        GoodData.connect(PARAMS[:gd_login], PARAMS[:gd_pass])
+        GoodData.project = PARAMS[:project_pid] if !PARAMS[:project_pid].nil? && !PARAMS[:project_pid].empty?
+    end
+
+    def self.subscribe_on_finish(event_type, channel, deploy, options={})
+      channel_uri = channel["channelConfiguration"]["meta"]["uri"]
+      process_id = deploy["process"]["links"]["self"].split('/').last
+      event_id = case event_type
+        when :success
+          "dataload.process.finish.ok"
+        when :failure
+          "dataload.process.finish.error"
+        else
+          fail "You specified unknown event \"#{event_type}\""
+        end
+
+      templates = {
+        :success => {
+          :message => "Just wanted to let you know that ETL for \"#{deploy["process"]["name"]}\" Succeeded",
+          :subject => "GoodData ETL SUCCESS: process with name \"#{deploy["process"]["name"]}\""
+        },
+        :failure => {
+          :message => "Just wanted to let you know that ETL for \"#{deploy["process"]["name"]}\" Failed",
+          :subject => "GoodData ETL FAILURE: process with name \"#{deploy["process"]["name"]}\""
+        }
+      }
+
+      templates_to_be_used = templates[event_type]
+      
+      data = {
+        :subscription => {
+          :triggers => [
+            {
+              :projectEventTrigger => {
+                :types => [event_id]
+              }
+            }
+          ],
+          :condition => {
+            :condition => {
+              :expression => "params.PROCESS_ID==\"#{process_id}\""
+            }
+          },
+          :subject => {
+            :template => {
+              :expression => templates_to_be_used[:subject]
+            }
+          },
+          :message => {
+            :template => {
+              :expression => templates_to_be_used[:message]
+            }
+          },
+          :channels => [channel_uri],
+          :meta => {
+            :title => "Notification for process #{process_id}"
+          }
+        }
+      }
+      profile_id = GoodData.connection.user["profile"].split("/").last
+      GoodData.post("/gdc/projects/#{PARAMS[:project_pid]}/users/#{profile_id}/subscriptions", data)
+    end
+
+    def self.clone_project(options={})
+      pid = case options[:blueprint]
+        when "goodsales"
+          "nt935rwzls50zfqwy6dh62tabu8h0ocy"
+        when nil
+          fail "Empty project not supported now"
+      end
+
+      project_name = PARAMS[:project_name]
+      fail "project name has to be filled in" if project_name.blank?
+      with_users  = options[:with_users]
+
+      export = {
+        :exportProject => {
+          :exportUsers => with_users ? 1 : 0,
+          :exportData => 1
+        }
+      }
+
+      result = GoodData.post("/gdc/md/#{pid}/maintenance/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[pid]
+
+      pr = {
+        :project => {
+          :content => {
+            :guidedNavigation => 1,
+            :driver => "Pg",
+            :authorizationToken => options[:token]
+          },
+          :meta => {
+            :title => project_name,
+            :summary => "Testing Project"
+          }
+        }
+      }
+      result = GoodData.post("/gdc/projects/", pr)
+      uri = result["uri"]
+      while(GoodData.get(uri)["project"]["content"]["state"] == "LOADING")
+        sleep(5)
+      end
+
+      new_project = GoodData::Project[uri]
+      
+      import = {
+        :importProject => {
+          :token => 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
+      GoodData.post "/gdc/projects/#{new_project.obj_id}/eventStore/stores", {:store => {:storeId => "es_0"}}
+      new_project.obj_id
+    end
+
+    def self.create_email_channel(options={}, &block)
+      email = options[:email]
+
+      data = {
+        :channelConfiguration => {
+          :configuration => {
+            :emailConfiguration => {
+              :to => email
+            }
+          },
+          :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] || "#{PARAMS[:project_name]}"
+      verbose = options[:verbose] || false
+      puts HighLine::color("Deploying #{dir}", HighLine::BOLD) if verbose
+      res = nil
+
+      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]
+
+        binding.pry
+
+        data = {
+            :process => {
+              :name => deploy_name,
+              :path => "/uploads/#{File.basename(temp.path)}"
+            }
+          }
+        res = if process_id.nil?
+          GoodData.post("/gdc/projects/#{PARAMS[:project_pid]}/dataload/processes", data)
+        else
+          GoodData.put("/gdc/projects/#{PARAMS[:project_pid]}/dataload/processes/#{process_id}", data)
+        end
+      end
+      puts HighLine::color("Deploy DONE #{dir}", HighLine::BOLD) if verbose
+      res
+    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["process"]["links"]["self"]
+          GoodData.delete(self_link)
+        end
+      else
+        deploy_graph(dir, options)
+      end
+    end
+
+    def self.generate_graph_template(name, target)
+      template_name = "#{name}_template.grf.erb"
+      render_template(template_name, PARAMS, :to_file => USER_DEFINED_GRAPHS_ROOT + target)
+    end
+
+
+    def self.generate(options)
+
+      only_flow = options[:only]
+      setup_clover_project(CLOVER_PROJECT_ROOT, :name => "etl-#{PARAMS[:project_name]}")
+      p = build_project
+      sources   = p.get_sources
+      datasets  = p.get_datasets
+      s3_backup = PARAMS[:S3_SECRET_ACCESS_KEY] && PARAMS[:S3_ACCESS_KEY_ID] && PARAMS[:S3_BUCKETNAME]
+
+      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?
+      fail "The flow you specified was not found" if flows.empty? && !only_flow.nil?
+      fail "There are no flows to generate from" if flows.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 "Tap \"#{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 => s3_backup
+                  })
+                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 => s3_backup
+                  })
+                end
+
+                step_no += 1
+              elsif s[:type] == :upload
+                source_name = s[:id] || f.name
+                dataset = datasets.find {|d| d[:id] == source_name}
+                
+                fail "Sink \"#{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("Tap #{source_name} was not found in current metadata") 
+                end
+                fail "Sink \"#{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
+                if s[:metadata_block].nil?
+                  s[:metadata_block] = [{:name=> flow_sources.first[:id] }]
+                end
+                
+                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] && 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
+>>>>>>> Stashed changes
+  end
+end