Updates the deployed list for bfs configuration of the pods.

Any file in /config/pods named *.cf is a pod config file.
356868
private void updateBfsPath(Result<Void> result)
  {
    _bfsPath.list(result.then(list->{ updateBfsPath(list); return null; }));
  }
925968
def update_config(cls, config_file, config):
        
        need_save = False
        # delete old env key
        if 'api' in config and 'env' in config['api']:
            del config['api']['env']
            need_save = True
        # convert old ssh_key configuration entry
        ssh_key = config.get('ssh_key')
        sshkeys = config.get('sshkey')
        if ssh_key and not sshkeys:
            config.update({'sshkey': [ssh_key]})
            need_save = True
        elif ssh_key and sshkeys:
            config.update({'sshkey': sshkeys.append(ssh_key)})
            need_save = True
        # remove old value
        if ssh_key:
            del config['ssh_key']
            need_save = True

        # save to disk
        if need_save:
            cls.save(config_file, config)
532751
private function updateRegistry()
    {
        if (!file_exists($this->listFilePath)) {
            $this->dumpRegistry();
        } else {
            $actualization = filemtime($this->listFilePath);
            if ($actualization > $this->registryActualTime) {
                $this->storage = require $this->listFilePath;
                $this->registryActualTime = $actualization;
            }
        }
    }
1120546
function updateIosPlist (targetFilePath, configItems) {
        var infoPlist = plist.parse(fs.readFileSync(targetFilePath, 'utf-8')),
            tempInfoPlist;

        _.each(configItems, function (item) {
            var key = item.parent;
            var plistXml = '<plist><dict><key>' + key + '</key>';
            plistXml += eltreeToXmlString(item.data) + '</dict></plist>';

            var configPlistObj = plist.parse(plistXml);
            infoPlist[key] = configPlistObj[key];
            logger.verbose("Write to plist; key="+key+"; value="+tostr(configPlistObj[key]));
        });

        tempInfoPlist = plist.build(infoPlist);
        tempInfoPlist = tempInfoPlist.replace(/<string>[\s\r\n]*<\/string>/g,'<string></string>');
        fs.writeFileSync(targetFilePath, tempInfoPlist, 'utf-8');
    }
672485
protected function update()
    {
        FileSystem::updateConfig();
        foreach (Daemon::$appInstances as $app) {
            foreach ($app as $appInstance) {
                $appInstance->handleStatus(AppInstance::EVENT_CONFIG_UPDATED);
            }
        }
    }
268783
def set_config(self, config):
    
    if self.config is None:
      self.config = { }
    self.config.update(config_to_api_list(config))
95945
def modify_config_file(updates):
    '''
    
    '''
    cmd = '/bin/sed '
    for key in updates:
        cmd = cmd + '-e \'s/^#*{key}.*=.*$/{key}={value}/\' '.format(key=key, value=updates[key])
    cmd = cmd + constants.default_conf_file
    status = run_command_get_output(cmd)
    write_to_disk(constants.default_conf_file, content=status['output'])
404853
public void setSafariBuiltinFavorites() {
    File[] files = app.listFiles(new FilenameFilter() {
      @Override
      public boolean accept(File dir, String name) {
        return name.startsWith("BuiltinFavorites") && name.endsWith(".plist");
      }
    });
    for (File plist : files) {
      setSafariBuiltinFavories(plist);
    }
  }
921301
def update_cache(force=False, cache_file=None):
    
    if not cache_file:
        cache_file = find_config()
    cache_config = devpipeline_configure.parser.read_config(cache_file)
    cache = devpipeline_configure.cache._CachedConfig(cache_config, cache_file)
    if force or _is_outdated(cache_file, cache):
        cache = devpipeline_configure.config.process_config(
            cache_config.get("DEFAULT", "dp.build_config"),
            os.path.dirname(cache_file),
            "build.cache",
            profiles=cache_config.get("DEFAULT", "dp.profile_name", fallback=None),
            overrides=cache_config.get("DEFAULT", "dp.overrides", fallback=None),
        )
        devpipeline_core.sanitizer.sanitize(
            cache, lambda n, m: print("{} [{}]".format(m, n))
        )
    return cache
932741
def update(self, **kwargs):
        
        # Update inherited configurations
        super(VrfConf, self).update(**kwargs)
        vrf_id = kwargs.get(ConfWithId.ID)
        vrf_rd = kwargs.get(ROUTE_DISTINGUISHER)
        vrf_rf = kwargs.get(VRF_RF)
        if (vrf_id != self.id or
                vrf_rd != self.route_dist or
                vrf_rf != self.route_family):
            raise ConfigValueError(desc='id/route-distinguisher/route-family'
                                   ' do not match configured value.')

        # Validate and update individual settings
        new_imp_rts, old_imp_rts = \
            self._update_import_rts(**kwargs)
        export_rts_changed = self._update_export_rts(**kwargs)
        soos_list_changed = self._update_soo_list(**kwargs)
        med_changed = self._update_med(**kwargs)
        re_export_needed = (export_rts_changed or
                            soos_list_changed or
                            med_changed)
        import_maps = kwargs.get(IMPORT_MAPS, [])
        re_import_needed = self._update_importmaps(import_maps)

        # If we did have any change in value of any settings, we notify
        # listeners
        if (new_imp_rts is not None or
                old_imp_rts is not None or
                re_export_needed or re_import_needed):
            evt_value = (
                new_imp_rts,
                old_imp_rts,
                import_maps,
                re_export_needed,
                re_import_needed
            )
            self._notify_listeners(VrfConf.VRF_CHG_EVT, evt_value)
        return True
1361661
def _update(self):
        
        with self._lock:
            if getmtime(self._filename) > self._last_modified:
                self._last_modified = getmtime(self._filename)
                self._book = ConfigParser(default_section='format')
                self._book.read(self._filename)
609667
private void updateData(List<UDeployApplication> uDeployApplications) {
        for (UDeployApplication application : uDeployApplications) {
            List<EnvironmentComponent> compList = new ArrayList<>();
            List<EnvironmentStatus> statusList = new ArrayList<>();
            long startApp = System.currentTimeMillis();

            for (Environment environment : uDeployClient
                    .getEnvironments(application)) {

                List<UDeployEnvResCompData> combinedDataList = uDeployClient
                        .getEnvironmentResourceStatusData(application,
                                environment);

                compList.addAll(getEnvironmentComponent(combinedDataList, environment, application));
                statusList.addAll(getEnvironmentStatus(combinedDataList));
            }
            if (!compList.isEmpty()) {
                List<EnvironmentComponent> existingComponents = envComponentRepository
                        .findByCollectorItemId(application.getId());
                envComponentRepository.delete(existingComponents);
                envComponentRepository.save(compList);
            }
            if (!statusList.isEmpty()) {
                List<EnvironmentStatus> existingStatuses = environmentStatusRepository
                        .findByCollectorItemId(application.getId());
                environmentStatusRepository.delete(existingStatuses);
                environmentStatusRepository.save(statusList);
            }

            log(" " + application.getApplicationName(), startApp);
        }
    }
607666
def update_all(self):
        
        self.update_path_labels()
        self.update_core_config_list_store()
        self.update_gui_config_list_store()
        self.update_libraries_list_store()
        self.update_shortcut_settings()
        self.check_for_preliminary_config()
1000763
protected void updateApiVersion(KubernetesResourceList list) {
    String version = getApiVersion();
    if (list != null && version != null && version.length() > 0) {
      List items = list.getItems();
      if (items != null) {
        for (Object item : items) {
          if (item instanceof HasMetadata) {
            updateApiVersion((HasMetadata) item);
          }
        }
      }
    }
  }
797720
def _update_container_host_config(self, service):
        
        if not isinstance(service, Service):
            raise TypeError("service must be an instance of Service")

        if service.dependencies:

            self._load_dependency_containers(service)

            if service.host_config.links:
                self._update_links(service)

            if service.host_config.volumes_from:
                self._update_volumes_from(service)
195016
private function updateConfig()
    {
        if ($this->getId('updated', 'anything') === false) {
            return;
        }
        $yaml = array();

        // Blog
        $yaml['blog'] = $this->config('blog');

        // Authors
        $yaml['authors'] = array();
        $authors = $this->config('authors');
        foreach ($this->db->all(array(
            'SELECT authors.path, authors.name',
            'FROM blog AS b',
            'INNER JOIN authors ON b.author_id = authors.id',
            'WHERE b.featured <= 0 AND b.published < 0 AND b.updated < 0 AND b.author_id != 0',
            'GROUP BY authors.id',
            'ORDER BY authors.name ASC',
        ), '', 'assoc') as $row) {
            $merge = (isset($authors[$row['path']])) ? $authors[$row['path']] : array();
            $yaml['authors'][$row['path']] = array_merge(array(
                'name' => $row['name'],
                'image' => '',
            ), $merge);
            unset($authors[$row['path']]);
        }
        foreach ($authors as $path => $values) {
            $yaml['authors'][$path] = $values;
        }

        // Categories
        $yaml['categories'] = array();
        $categories = $this->config('categories');
        $hier = new Hierarchy($this->db, 'categories');
        if ($this->getId('updated', 'categories')) {
            $hier->refresh('name');
        }
        $tree = $hier->tree(array('path', 'name'));
        unset($hier);
        foreach ($tree as $row) {
            $merge = (isset($categories[$row['path']])) ? $categories[$row['path']] : array();
            $yaml['categories'][$row['path']] = array_merge(array(
                'name' => $row['name'],
            ), $merge);
            unset($categories[$row['path']]);
        }
        foreach ($categories as $path => $values) {
            $yaml['categories'][$path] = $values;
        }

        // Tags
        $yaml['tags'] = array();
        $tags = $this->config('tags');
        foreach ($this->db->all(array(
            'SELECT tags.path, tags.name',
            'FROM tagged AS t',
            'INNER JOIN tags ON t.tag_id = tags.id',
            'GROUP BY tags.id',
            'ORDER BY tags.name ASC',
        ), '', 'assoc') as $row) {
            $merge = (isset($tags[$row['path']])) ? $tags[$row['path']] : array();
            $yaml['tags'][$row['path']] = array_merge(array(
                'name' => $row['name'],
            ), $merge);
            unset($tags[$row['path']]);
        }
        foreach ($tags as $path => $values) {
            $yaml['tags'][$path] = $values;
        }

        file_put_contents($this->folder.'config.yml', Yaml::dump($yaml, 3));
    }
318102
function updatePlatformConfig(platform) {
        var configData = parseConfigXml(platform),
            platformPath = path.join(rootdir, 'platforms', platform);

        _.each(configData, function (configItems, targetFileName) {
            var targetFilePath;
            if (platform === 'ios') {
                if (targetFileName.indexOf("Info.plist") > -1) {
                    targetFileName =  projectName + '-Info.plist';
                    targetFilePath = path.join(platformPath, projectName, targetFileName);
                    ensureBackup(targetFilePath, platform, targetFileName);
                    updateIosPlist(targetFilePath, configItems);
                }else if (targetFileName === "project.pbxproj") {
                    targetFilePath = path.join(platformPath, projectName + '.xcodeproj', targetFileName);
                    ensureBackup(targetFilePath, platform, targetFileName);
                    updateIosPbxProj(targetFilePath, configItems);
                    updateXCConfigs(configItems, platformPath);
                }

            } else if (platform === 'android' && targetFileName === 'AndroidManifest.xml') {
                targetFilePath = path.join(platformPath, targetFileName);
                ensureBackup(targetFilePath, platform, targetFileName);
                updateAndroidManifest(targetFilePath, configItems);
            } else if (platform === 'wp8') {
                targetFilePath = path.join(platformPath, targetFileName);
                ensureBackup(targetFilePath, platform, targetFileName);
                updateWp8Manifest(targetFilePath, configItems);
            }
        });
    }