Run this section and print out information.
1528
def run(self):
        """"""
        if self.mloginfo.logfile.repl_set:
            print("    rs name: %s" % self.mloginfo.logfile.repl_set)
            print(" rs members: %s"
                  % (self.mloginfo.logfile.repl_set_members
                     if self.mloginfo.logfile.repl_set_members
                     else "unknown"))
            print(" rs version: %s"
                  % (self.mloginfo.logfile.repl_set_version
                     if self.mloginfo.logfile.repl_set_version
                     else "unknown"))
            print("rs protocol: %s"
                  % (self.mloginfo.logfile.repl_set_protocol
                     if self.mloginfo.logfile.repl_set_protocol
                     else "unknown"))
        else:
            print("  no rs info changes found")
1294847
def run(self):
        """"""
        last_status = ''
        # lambda is used to avoid http://bugs.python.org/issue30473 in py36
        start_times = defaultdict(lambda: datetime.datetime.now())
        max_stage_id = -1

        status = self.sc.statusTracker()
        while True:
            with self.condition:
                if self.sc._jsc is None or not self.alive:
                    # End the thread
                    self.paused = True
                    break
                elif self.paused:
                    # Pause the thread
                    self.condition.wait()
            stage_ids = status.getActiveStageIds()
            progressbar_list = []
            # Only show first 3
            stage_counter = 0
            current_max_stage = max_stage_id
            for stage_id in stage_ids:
                stage_info = status.getStageInfo(stage_id)
                if stage_info and stage_info.numTasks > 0:
                    # Set state variables used for flushing later
                    current_max_stage = stage_id
                    stage_counter += 1
                    td = datetime.datetime.now() - start_times[stage_id]
                    s = _format_stage_info(self.bar_width, stage_info, td, self.timedelta_formatter)
                    progressbar_list.append(s)
                if stage_counter == 3:
                    break

            # Ensure that when we get a new maximum stage id we print a \n
            # to make the progress bar go on to the next line.
            if current_max_stage > max_stage_id:
                if last_status != '':
                    sys.stderr.write("\n")
                sys.stderr.flush()
                max_stage_id = current_max_stage

            new_status = ' '.join(progressbar_list)
            if new_status != last_status:
                sys.stderr.write("\r" + new_status)
                sys.stderr.flush()
                last_status = new_status
            time.sleep(self.sleep_time)
379820
public function run() {
    $values = $this->formValues;

    try {
      $creative = $this->service->creatives->get($values['account_id'],
          $values['buyer_creative_id'], $values['ad_group_id']);
      print '<h2>Found creative</h2>';
      $this->printResult($creative);
    } catch (Google_Exception $ex) {
      if ($ex->getCode() == 404 || $ex->getCode() == 403) {
        print '<h1>Creative not found or can\'t access creative</h1>';
      } else {
        throw $ex;
      }
    }
  }
38682
public function run() {
    if ($this->_expector->output && $this->_expector->output->isVerbose()) {
      $this->_expector->output->writeln($this->_indent . $this->_label); 
    }
    
    foreach ($this->_tests as $test) {
      $test->run();
    }
  }
503532
public function run()
	{
		$this->style->getCharacter()->setIsUnderline(
			$this->parameter === null || (bool) $this->parameter
		);
		
		return;
	}
1091348
def _run():
    """"""

    args = parse_args()

    # parse custom parameters
    custom_meta = None
    if args.custom_meta:
        print "Adding custom parameters:"
        custom_meta = {}
        try:
            for item in args.custom_meta.split(','):
                key, value = item.split(':')
                custom_meta[key] = value
                print 'key: %s, value: %s' % (key, value)
        except Exception as e:
            sys.stderr.write("ERROR: Can not parse custom meta tags! %s\n" % (str(e)))

    # we need to store some persistent info, so check if a config file
    # exists (default location is ~/.centinel/config.ini). If the file
    # does not exist, then create a new one at run time
    configuration = centinel.config.Configuration()
    if args.config:
        configuration.parse_config(args.config)
    else:
        # if the file does not exist, then the default config file
        # will be used
        new_configuration = None
        if os.path.exists(DEFAULT_CONFIG_FILE):
            configuration.parse_config(DEFAULT_CONFIG_FILE)
        else:
            print 'Configuration file does not exist. Creating a new one.'
            new_configuration = centinel.config.Configuration()

        if not ('version' in configuration.params and
                configuration.params['version']['version'] == centinel.__version__):
            if not args.update_config:
                print ('WARNING: configuration file is from '
                       'a different version (%s) of '
                       'Centinel. Run with --update-config to update '
                       'it.' % (configuration.params['version']['version']))
            else:
                new_configuration = centinel.config.Configuration()
                backup_path = DEFAULT_CONFIG_FILE + ".old"
                new_configuration.update(configuration, backup_path)

        if new_configuration is not None:
            configuration = new_configuration
            configuration.write_out_config(DEFAULT_CONFIG_FILE)
            print 'New configuration written to %s' % (DEFAULT_CONFIG_FILE)
            if args.update_config:
                sys.exit(0)

    if args.verbose:
        if 'log' not in configuration.params:
            configuration.params['log'] = dict()
        configuration.params['log']['log_level'] = logging.DEBUG

    # add custom meta values from CLI
    if custom_meta is not None:
        if 'custom_meta' in configuration.params:
            configuration.params['custom_meta'].update(custom_meta)
        else:
            configuration.params['custom_meta'] = custom_meta

    centinel.conf = configuration.params
    client = centinel.client.Client(configuration.params)
    client.setup_logging()
    # disable cert verification if the flag is set
    if args.no_verify:
        configuration.params['server']['verify'] = False

    user = centinel.backend.User(configuration.params)
    # Note: because we have mutually exclusive arguments, we don't
    # have to worry about multiple arguments being called
    if args.sync:
        centinel.backend.sync(configuration.params)
    elif args.consent:
        user.informed_consent()
    elif args.daemonize:
        # if we don't have a valid binary location, then exit
        if not os.path.exists(args.binary):
            print "Error: no binary found to daemonize"
            exit(1)
        centinel.daemonize.daemonize(args.auto_update, args.binary,
            args.user)
    else:
        client.run()
1172254
def run (self):
        """"""
        try:
            self.run_checked()
        except KeyboardInterrupt:
            thread.interrupt_main()
        except Exception:
            self.internal_error()
487620
@Override
    public void run() {

        try {
            // do the content check
            m_contentCheck.startContentCheck(m_cms, getReport());
        } catch (Exception e) {
            getReport().println(e);
            if (LOG.isErrorEnabled()) {
                LOG.error(e.getLocalizedMessage());
            }
        }
    }
885312
def run(self, **kwargs):
        '''
        
        '''
        self.report_start()
        for bench in self.benchmarks:
            bench = bench(before=self.report_before_method,
                      after=self.report_after_method,
                      after_each=self.report_progress,
                      debug=self.debug,
                      **kwargs)
            self.report_before_class(bench)
            bench.run()
            self.report_after_class(bench)
            self.runned.append(bench)
        self.report_end()
283522
def run(self):
        
        self.find_new()
        for n in self.news:
            print("{0}".format(n))
        print("")
        self.msg.template(78)
        print("| Installed {0} new configuration files:".format(
            len(self.news)))
        self.msg.template(78)
        self.choices()
288944
def print(self):
        
        print(tabulate(
            ((i, *row) for i, row in enumerate(self.results, 1)),
            headers=self.headers,
        ))
56267
def run(self):
        """"""
        for rel_path in sorted(self.paths):
            file_path = join(self.data_dir, rel_path)
            self.minify(file_path)

        after = self.size_of(self.after_total)
        before = self.size_of(self.before_total)
        saved = self.size_of(self.before_total - self.after_total)

        template = '\nTotal: ' \
                   '\033[92m{}\033[0m -> \033[92m{}\033[0m. ' \
                   'Compressed: \033[92m{}\033[0m\n'

        print(template.format(before, after, saved))
590917
def report(self):
        """"""
        from pprint import pprint
        print "s2n"
        pprint(self.symbol2number)
        print "n2s"
        pprint(self.number2symbol)
        print "states"
        pprint(self.states)
        print "dfas"
        pprint(self.dfas)
        print "labels"
        pprint(self.labels)
        print "start", self.start
768634
def run(self):
        '''
        
        '''
        # Loading yaml
        self.load_yaml()

        # Print paths from schema
        section_title = '**API Paths**'
        self.write(section_title)
        self.write('=' * len(section_title))
        self.print_paths()

        # Print models
        section_title = '**Schemas Description**'
        self.write(section_title)
        self.write('=' * len(section_title))
        self.print_schemas()

        # Render by sphinx
        node = nodes.section()
        node.document = self.state.document
        nested_parse_with_titles(self.state, self.__view_list, node)
        return node.children
327538
@Override
    public void run() {

        try {
            getReport().println(
                Messages.get().container(Messages.RPT_DB_PUBLOCKS_BEGIN_0),
                I_CmsReport.FORMAT_HEADLINE);
            CmsObject cms = getCms();
            CmsLockFilter filter = CmsLockFilter.FILTER_ALL;
            filter = filter.filterType(CmsLockType.PUBLISH);

            Iterator<String> it = m_resources.iterator();
            while (it.hasNext()) {
                String paramResName = it.next();
                getReport().println(
                    Messages.get().container(Messages.RPT_DB_PUBLOCKS_READLOCKS_1, paramResName),
                    I_CmsReport.FORMAT_NOTE);
                Iterator<String> itResources = cms.getLockedResources(paramResName, filter).iterator();
                while (itResources.hasNext()) {
                    String resName = itResources.next();
                    if (!cms.existsResource(resName, CmsResourceFilter.ALL)) {
                        getReport().println(
                            Messages.get().container(Messages.RPT_DB_PUBLOCKS_UNLOCKING_1, resName),
                            I_CmsReport.FORMAT_DEFAULT);
                        OpenCms.getMemoryMonitor().uncacheLock(cms.getRequestContext().addSiteRoot(resName));
                        continue;
                    }
                    Iterator<CmsResource> itSiblings = cms.readSiblings(resName, CmsResourceFilter.ALL).iterator();
                    while (itSiblings.hasNext()) {
                        CmsResource res = itSiblings.next();
                        getReport().println(
                            Messages.get().container(Messages.RPT_DB_PUBLOCKS_UNLOCKING_1, cms.getSitePath(res)),
                            I_CmsReport.FORMAT_DEFAULT);
                        OpenCms.getMemoryMonitor().uncacheLock(res.getRootPath());
                    }
                }
            }
            getReport().println(Messages.get().container(Messages.RPT_DB_PUBLOCKS_END_0), I_CmsReport.FORMAT_HEADLINE);
        } catch (Throwable exc) {
            getReport().println(
                Messages.get().container(Messages.RPT_DB_PUBLOCKS_FAILED_0),
                I_CmsReport.FORMAT_WARNING);
            getReport().println(exc);
            m_error = exc;
        }
    }
764007
public function run()
	{
		$id=$this->getId();
		if(isset($this->htmlOptions['id']))
			$id=$this->htmlOptions['id'];
		else
			$this->htmlOptions['id']=$id;

		echo CHtml::openTag($this->tagName,$this->htmlOptions)."\n";

		$tabsOut="";
		$contentOut="";
		$tabCount=0;

		foreach($this->tabs as $title=>$content)
		{
			$tabId=(is_array($content) && isset($content['id']))?$content['id']:$id.'_tab_'.$tabCount++;

			if(!is_array($content))
			{
				$tabsOut.=strtr($this->headerTemplate,array('{title}'=>$title,'{url}'=>'#'.$tabId,'{id}'=>'#'.$tabId))."\n";
				$contentOut.=strtr($this->contentTemplate,array('{content}'=>$content,'{id}'=>$tabId))."\n";
			}
			elseif(isset($content['ajax']))
			{
				$tabsOut.=strtr($this->headerTemplate,array('{title}'=>$title,'{url}'=>CHtml::normalizeUrl($content['ajax']),'{id}'=>'#'.$tabId))."\n";
			}
			else
			{
				$tabsOut.=strtr($this->headerTemplate,array('{title}'=>$title,'{url}'=>'#'.$tabId,'{id}'=>$tabId))."\n";
				if(isset($content['content']))
					$contentOut.=strtr($this->contentTemplate,array('{content}'=>$content['content'],'{id}'=>$tabId))."\n";
			}
		}
		echo "<ul>\n".$tabsOut."</ul>\n";
		echo $contentOut;
		echo CHtml::closeTag($this->tagName)."\n";

		$options=CJavaScript::encode($this->options);
		Yii::app()->getClientScript()->registerScript(__CLASS__.'#'.$id,"jQuery('#{$id}').tabs($options);");
	}
1285564
public function run()
    {
        $table = $this->table(CMS_TABLE_GROUPS);
        $table->insert($this->records)->save();
    }