All build trains, even if there is no TestFlight
19465
def all_build_trains(app_id: nil, platform: 'ios')
      platform = 'ios' if platform.nil?
      r = request(:get, "ra/apps/#{app_id}/buildHistory?platform=#{platform}")
      handle_itc_response(r.body)
    end
336056
def build(self):
        """"""

        # If there's no output tube, it means that this stage
        # is at the end of a fork (hasn't been linked to any stage downstream).
        # Therefore, create one output tube.
        if not self._output_tubes:
            self._output_tubes.append(self._worker_class.getTubeClass()())

        self._worker_class.assemble(
            self._worker_args,
            self._input_tube,
            self._output_tubes,
            self._size,
            self._disable_result,
            self._do_stop_task,
            )

        # Build all downstream stages.
        for stage in self._next_stages:
            stage.build()
401553
def builds(self, request, pk=None):
        
        builds = self.get_object().builds.prefetch_related('test_runs').order_by('-datetime')
        page = self.paginate_queryset(builds)
        serializer = BuildSerializer(page, many=True, context={'request': request})
        return self.get_paginated_response(serializer.data)
516266
def build(options = {})
      DuckMap.logger.info "\r\n\r\n====================================================================="
      DuckMap.logger.info "#{self.class.name} session begin at: #{Time.now}"
      DuckMap.logger.info "options: #{options}"

      verbose = options[:verbose].blank? ? false : true

      # always replace ALL of the existing content, so, the list is always current.
      # actions / views may have been deleted, renamed, etc.
      content = {sitemap: {}}
      grand_total = 0

      # controllers full physical path for the current app.
      base_dir = File.join(Rails.root, "app", "controllers").to_s

      # this is a little bit complex.
      # - traverse the entire directory structure for controllers.
      # - for each
      #   - inline gsub! to remove the base_dir.
      #   - inline gsub! to remove _controller.
      #   - then, prevent the application controller from making it into the list as
      #     there should not be any actions / views for the application controller.


      list = Dir["#{File.join(base_dir, "**", "*.rb")}"].each {|f| f.gsub!("#{base_dir}/", "").gsub!("_controller.rb", "")}.map.find_all {|x| x.eql?("application") ? false : true}

      DuckMap.console "Total number of controllers found within the app: #{list.length}"
      DuckMap.console "Views Controller"
      DuckMap.console "-------------------------------------------------------------"

      DuckMap.logger.show_console = verbose ? true : false

      list.each do |controller|

        file_spec = File.join("app", "views", controller)

        clazz = "#{controller}_controller".camelize.constantize

        DuckMap.console "===================================================================================="
        DuckMap.console "controller: #{controller.ljust(30)}  path: #{file_spec}"

        actions = {}
        methods = clazz.action_methods

        methods.each do |action|

          latest_timestamp = nil
          winner = nil

          DuckMap.console "    action: #{action}"

          Dir["#{File.join(file_spec, action)}.html.*"].each do |view|

            begin
              view_timestamp = File.stat(File.join(Rails.root, view)).mtime
              if view_timestamp.blank?
                DuckMap.console "          : cannot stat file: #{view}"
              else

                if latest_timestamp.blank? || view_timestamp > latest_timestamp
                  latest_timestamp = view_timestamp
                  winner = "timestamp from file"
                  DuckMap.console "          : Using    file timestamp? YES #{view}"
                  DuckMap.console "          :     file timestamp #{view_timestamp} greater than: #{latest_timestamp}"
                else
                  DuckMap.console "          : Using    file timestamp? NO #{view}"
                  DuckMap.console "          :     file timestamp #{view_timestamp} less than: #{latest_timestamp}"
                end

              end
            rescue Exception => e
              DuckMap.logger.debug "#{e}"
            end

            begin
              output = %x(git log --format='%ci' -- #{view} | head -n 1)
              if output.blank?
                DuckMap.console "          : cannot get date from GIT for file: #{view}"
              else

                view_timestamp = LastMod.to_date(output)
                if latest_timestamp.blank? || view_timestamp > latest_timestamp
                  latest_timestamp = view_timestamp
                  winner = "timestamp from GIT"
                  DuckMap.console "          : Using     GIT timestamp? YES #{view}"
                  DuckMap.console "          :     file timestamp #{view_timestamp} greater than: #{latest_timestamp}"
                else
                  DuckMap.console "          : Using     GIT timestamp? NO #{view}"
                  DuckMap.console "          :     file timestamp #{view_timestamp} less than: #{latest_timestamp}"
                end

              end
            rescue Exception => e
              DuckMap.logger.debug "#{e}"
            end

            begin
              view_timestamp = LastMod.to_date(I18n.t("#{controller.gsub("/", ".")}.#{action}", :locale => :sitemap))

              if view_timestamp.blank?
                DuckMap.console "          : cannot find item in locale sitemap.yml for file: #{view}"
              else

                view_timestamp = LastMod.to_date(output)
                if latest_timestamp.blank? || view_timestamp > latest_timestamp
                  latest_timestamp = view_timestamp
                  winner = "timestamp from locale sitemap.yml"
                  DuckMap.console "          : Using  locale timestamp? YES #{view}"
                  DuckMap.console "          :     file timestamp #{view_timestamp} greater than: #{latest_timestamp}"
                else
                  DuckMap.console "          : Using  locale timestamp? NO #{view}"
                  DuckMap.console "          :     file timestamp #{view_timestamp} less than: #{latest_timestamp}"
                end

              end

            rescue Exception => e
              DuckMap.logger.debug "#{e}"
            end

            DuckMap.console "          : winner #{winner}"

            begin
              actions.merge!(action => latest_timestamp.strftime("%m/%d/%Y %H:%M:%S"))
            rescue Exception => e
              DuckMap.logger.debug "#{e}"
            end

          end
        end

        # add all of the actions found for the current controller to the :sitemap section of the yaml file.
        if actions.length > 0
          grand_total += actions.length
          namespaces = controller.split("/")
          content[:sitemap] = merge_controller(content[:sitemap], namespaces, 0, actions)

          DuckMap.logger.show_console = true
          DuckMap.console "#{actions.length.to_s.rjust(5)} #{controller}"
          DuckMap.logger.show_console = verbose ? true : false

        end

      end

      DuckMap.logger.show_console = true
      DuckMap.console "\r\nTotal number of views synchronized: #{grand_total}\r\n"
      DuckMap.logger.info "#{self.class.name} session end at: #{Time.now}"
      DuckMap.logger.info "---------------------------------------------------------------------"

      # done.
      write_config(content)
      DuckMap.console "done."

    end
363637
def autobuild_onlycopy():
    
    try:
        # Build only release information
        family = utilities.get_family('module_settings.json')
        autobuild_release(family)

        Alias('release', os.path.join('build', 'output'))
        Default(['release'])
    except unit_test.IOTileException as e:
        print(e.format())
        Exit(1)
991697
def build(self):
        
        if not self.build_cmds:
            LOGGER.debug('No build commands were found, skipping build step')

        with LogTask('Building {} disk {}'.format(self.name, self.disk_path)):
            for command in self.build_cmds:
                with LogTask('Running command {}'.format(command.name)):
                    LOGGER.debug(command.cmd)
                    result = utils.run_command(command.cmd)
                    if result:
                        raise BuildException(result.err)
168207
def build(*onts, fail=False, n_jobs=9, write=True):
    
    tail = lambda:tuple()
    lonts = len(onts)
    if lonts > 1:
        for i, ont in enumerate(onts):
            if ont.__name__ == 'parcBridge':
                onts = onts[:-1]
                def tail(o=ont):
                    return o.setup(),
                if i != lonts - 1:
                    raise ValueError('parcBridge should be built last to avoid weird errors!')
    # ont_setup must be run first on all ontologies
    # or we will get weird import errors
    if n_jobs == 1 or True:
        return tuple(ont.make(fail=fail, write=write) for ont in
                     tuple(ont.setup() for ont in onts) + tail())

    # have to use a listcomp so that all calls to setup()
    # finish before parallel goes to work
    return Parallel(n_jobs=n_jobs)(delayed(o.make)(fail=fail, write=write)
                                   for o in
                                   #[ont_setup(ont) for ont in onts])
                                   (tuple(Async()(deferred(ont.setup)()
                                                  for ont in onts)) + tail()
                                    if n_jobs > 1
                                    else [ont.setup()
                                          for ont in onts]))
1190936
def launch_one_at_a_time(language, locale, device_type, launch_arguments)
      prepare_for_launch([device_type], language, locale, launch_arguments)

      add_media([device_type], :photo, launcher_config.add_photos) if launcher_config.add_photos
      add_media([device_type], :video, launcher_config.add_videos) if launcher_config.add_videos

      open_simulator_for_device(device_type)

      command = TestCommandGeneratorXcode8.generate(device_type: device_type, language: language, locale: locale)

      if locale
        UI.header("#{device_type} - #{language} (#{locale})")
      else
        UI.header("#{device_type} - #{language}")
      end

      execute(command: command, language: language, locale: locale, device_type: device_type, launch_args: launch_arguments)

      raw_output = File.read(TestCommandGeneratorXcode8.xcodebuild_log_path(device_type: device_type, language: language, locale: locale))

      dir_name = locale || language

      return Collector.fetch_screenshots(raw_output, dir_name, device_type, launch_arguments.first)
    end
522967
def builds
      @builds ||= Collection::Build.new(self, name: name) do
        Resource::Build.all(name)
      end
    end
856931
def Build(self):
    """"""
    self.SetupVars()
    self.Clean()

    if not os.path.exists(args.grr_src):
      self.GitCheckoutGRR()
    proto_sdist = self.MakeProtoSdist()
    core_sdist = self.MakeCoreSdist()
    client_sdist = self.MakeClientSdist()
    client_builder_sdist = self.MakeClientBuilderSdist()

    self.InstallGRR(proto_sdist)
    self.InstallGRR(core_sdist)
    self.InstallGRR(client_sdist)
    self.InstallGRR(client_builder_sdist)
    self.BuildTemplates()
    if args.test_repack_install:
      self._RepackTemplates()
      self._InstallInstallers()
117588
def setup_rake_dependencies(task, multitask = nil)
      dependencies.reverse_each do |d|
        begin
          bb = ALL_BUILDING_BLOCKS[d]
          raise "Error: tried to add the dependencies of \"#{d}\" to \"#{@name}\" but such a building block could not be found!" unless bb

          if multitask and bb.pre_step
            multitask.prerequisites.unshift(bb.get_task_name)
          else
            task.prerequisites.unshift(bb.get_task_name)
          end
        rescue ExitHelperException
          raise
        rescue Exception => e
          Printer.printError e.message
          ExitHelper.exit(1)
        end
      end

      task
    end
647663
public void train() {
    if (flags.trainFiles != null) {
      train(flags.baseTrainDir, flags.trainFiles, defaultReaderAndWriter);
    } else if (flags.trainFileList != null) {
      String[] files = flags.trainFileList.split(",");
      train(files, defaultReaderAndWriter);
    } else {
      train(flags.trainFile, defaultReaderAndWriter);
    }
  }
324799
def run_build(which_build='default', options={})
      formatter = options[:formatter] || Fudge::Formatters::Simple.new
      output_start(which_build, formatter)
      status = run(which_build, options)
      output_status(status, formatter)
    end
822047
def clean_directories!
      all_build_files = File.join(@app.config[:build_dir], '**', '*')

      empty_directories = Dir[all_build_files].select do |d|
        File.directory?(d)
      end

      empty_directories.each do |d|
        remove_file d, force: true if Pathname(d).children.empty?
      end
    end
1356745
@Override
	public void spawnTracks() {
		for (int setIndex = 0; setIndex < sets.length; setIndex++) {
			SetTrackInfo<Desc> info = sets[setIndex];

			// setup data structures
			if( info.isAssociated.length < info.featDst.size ) {
				info.isAssociated = new boolean[ info.featDst.size ];
			}

			// see which features are associated in the dst list
			for( int i = 0; i < info.featDst.size; i++ ) {
				info.isAssociated[i] = false;
			}

			for( int i = 0; i < info.matches.size; i++ ) {
				info.isAssociated[info.matches.data[i].dst] = true;
			}

			// create new tracks from latest unassociated detected features
			for( int i = 0; i < info.featDst.size; i++ ) {
				if( info.isAssociated[i] )
					continue;

				Point2D_F64 loc = info.locDst.get(i);
				addNewTrack(setIndex, loc.x,loc.y,info.featDst.get(i));
			}
		}

	}
636065
def run(self):
        

        self.sanity_check()

# TODO - check for devel
#        if not self.version:
#            raise Exception("no version")
# XXX check attr exist
        if not self.release_environment:
            raise Exception("no instance name")

        time_start = time.time()

        cwd = os.getcwd()

        who = getpass.getuser()
        self._make_outdirs()

        append_notices = ""
        if hasattr(self, 'opt_end'):
            append_notices = ". shortened push, only to %s stage" % self.opt_end
        if self.is_devel:
            append_notices += ". devel build"
        if hasattr(self, 'append_notices'):
            append_notices += self.append_notices

        line = "%s %s %s by %s%s" % (
            sys.argv[0], self.version, self.release_environment, who, append_notices)
        b = 'deploy begin %s' % line
        e = 'deploy done %s' % line

        if self.chatty:
            self.alact(b)

        ok = False
        stage_passed = None
        try:
            for stage in self.stages[self.stage_start:self.stage_end]:
                self.debug_msg("stage %s starting" % (stage,))
                getattr(self, stage)()
                self.chdir(cwd)
                stage_passed = stage
                self.debug_msg("stage %s complete" % (stage,))
            ok = True
        finally:
            if not ok:
                if self.chatty:
                    if not stage_passed:
                        self.alact(
                            'deploy failed %s. completed no stages' % line)
                    else:
                        self.alact('deploy failed %s. completed %s' %
                                   (line, stage_passed))
        self.status_msg('[OK]')
        if self.chatty:
            self.alact('%s in %0.3f sec' % (e, time.time() - time_start))

        return 0
769094
def run_build(self, compiler=GCC, inputs=None, output=None):
        
        logger.info("Running build steps ...")
        self.run_configure(mandatory=False)
        self.run_make(mandatory=False)
        self.run_compiler(compiler=compiler,
                          inputs=inputs,
                          output=output)