Updating one configuration
548841
@RequestMapping(value = "configurations/{name}/update", method = RequestMethod.PUT)
    public JIRAConfiguration updateConfiguration(@PathVariable String name, @RequestBody JIRAConfiguration configuration) {
        jiraConfigurationService.updateConfiguration(name, configuration);
        return getConfiguration(name);
    }
884165
@RequestMapping(value = "configurations/{name:.*}/update", method = RequestMethod.PUT)
    public SVNConfiguration updateConfiguration(@PathVariable String name, @RequestBody SVNConfiguration configuration) {
        svnConfigurationService.updateConfiguration(name, configuration);
        return getConfiguration(name);
    }
873839
def update(self, ng_template_id, name=NotUpdated, plugin_name=NotUpdated,
               plugin_version=NotUpdated, flavor_id=NotUpdated,
               description=NotUpdated, volumes_per_node=NotUpdated,
               volumes_size=NotUpdated, node_processes=NotUpdated,
               node_configs=NotUpdated, floating_ip_pool=NotUpdated,
               security_groups=NotUpdated, auto_security_group=NotUpdated,
               availability_zone=NotUpdated,
               volumes_availability_zone=NotUpdated, volume_type=NotUpdated,
               image_id=NotUpdated, is_proxy_gateway=NotUpdated,
               volume_local_to_instance=NotUpdated, use_autoconfig=NotUpdated,
               shares=NotUpdated, is_public=NotUpdated,
               is_protected=NotUpdated, volume_mount_prefix=NotUpdated,
               boot_from_volume=NotUpdated,
               boot_volume_type=NotUpdated,
               boot_volume_availability_zone=NotUpdated,
               boot_volume_local_to_instance=NotUpdated):
        """"""

        data = {}
        self._copy_if_updated(
            data, name=name, plugin_name=plugin_name,
            plugin_version=plugin_version, flavor_id=flavor_id,
            description=description, volumes_per_node=volumes_per_node,
            volumes_size=volumes_size, node_processes=node_processes,
            node_configs=node_configs, floating_ip_pool=floating_ip_pool,
            security_groups=security_groups,
            auto_security_group=auto_security_group,
            availability_zone=availability_zone,
            volumes_availability_zone=volumes_availability_zone,
            volume_type=volume_type, image_id=image_id,
            is_proxy_gateway=is_proxy_gateway,
            volume_local_to_instance=volume_local_to_instance,
            use_autoconfig=use_autoconfig, shares=shares,
            is_public=is_public, is_protected=is_protected,
            volume_mount_prefix=volume_mount_prefix,
            boot_from_volume=boot_from_volume,
            boot_volume_type=boot_volume_type,
            boot_volume_availability_zone=boot_volume_availability_zone,
            boot_volume_local_to_instance=boot_volume_local_to_instance
        )

        return self._patch('/node-group-templates/%s' % ng_template_id, data,
                           'node_group_template')
1083076
public function updateConfigurationSuccess()
    {
        $url     = route(area() . '.modules.index');
        $message = trans('antares/foundation::response.extensions.configuration-success');

        return $this->redirectWithMessage($url, $message);
    }
665
def update_build_configuration(id, **kwargs):
    
    data = update_build_configuration_raw(id, **kwargs)
    if data:
        return utils.format_json(data)
104903
def updateConfig(self, eleobj, config, type='simu'):
        
        eleobj.setConf(config, type=type)
201214
def merge_config(self, user_config):
        '''
        
        '''

        # provisioanlly update the default configurations with the user preferences
        temp_data_config = copy.deepcopy(self.data_config).update(user_config)
        temp_model_config = copy.deepcopy(self.model_config).update(user_config)
        temp_conversation_config = copy.deepcopy(self.conversation_config).update(user_config)

        # if the new configurations validate, apply them
        if validate_data_config(temp_data_config):
            self.data_config = temp_data_config
        if validate_model_config(temp_model_config):
            self.model_config = temp_model_config
        if validate_conversation_config(temp_conversation_config):
            self.conversation_config = temp_conversation_config
672485
protected function update()
    {
        FileSystem::updateConfig();
        foreach (Daemon::$appInstances as $app) {
            foreach ($app as $appInstance) {
                $appInstance->handleStatus(AppInstance::EVENT_CONFIG_UPDATED);
            }
        }
    }
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()
799037
def update(connection, force_download):
    """"""
    manager.database.update(
        connection=connection,
        force_download=force_download
    )
1075134
def _update_cinder_config(cls):
        """"""
        cls._config_string_io.seek(0)
        cls._parser.write(cls._config_string_io)

        # Check if we have any multiopt
        cls._config_string_io.seek(0)
        current_cfg = cls._config_string_io.read()
        if '\n\t' in current_cfg:
            cls._config_string_io.seek(0)
            cls._config_string_io.write(current_cfg.replace('\n\t', '\n'))

        cls._config_string_io.seek(0)
        cfg.CONF.reload_config_files()
1230318
def update_config
      if File.exist?(config_file)
        Pkgr.debug "Loading #{distribution.slug} from #{config_file}."
        @config = Config.load_file(config_file, distribution.slug).merge(config)
        Pkgr.debug "Found .pkgr.yml file. Updated config is now: #{config.inspect}"

        # update distribution config
        distribution.config = @config

        # FIXME: make Config the authoritative source of the runner config (distribution only tells the default runner)
        if @config.runner
          type, *version = @config.runner.split("-")
          distribution.runner = Distributions::Runner.new(type, version.join("-"))
        end
      end
      config.distribution = distribution
      config.env.variables.push("TARGET=#{distribution.target}")
      # useful for templates that need to read files
      config.source_dir = source_dir
      config.build_dir = build_dir
    end
1189789
def add_configuration(self, configuration, collect_another_source, done, result, src):
        """"""
        if "includes" in result:
            for include in result["includes"]:
                collect_another_source(include)
        configuration.update(result, source=src)
448573
def update_configuration(app):
    """"""
    config = app.config
    project = config.project
    config_dir = app.env.srcdir
    sys.path.insert(0, os.path.join(config_dir, '..'))

    config.html_theme_path.append(os.path.relpath(os.path.join(os.path.abspath(os.path.dirname(__file__)), 'themes'), config_dir))
    if not config.html_logo:
        config.html_logo = os.path.relpath(os.path.join(STATIC_PATH, 'safari_logo.png'), config_dir)
    if not config.html_favicon:
        config.html_favicon = os.path.relpath(os.path.join(STATIC_PATH, 'favicon.ico'), config_dir)
    config.html_static_path.append(os.path.relpath(STATIC_PATH, config_dir))
    if not config.htmlhelp_basename:
        config.htmlhelp_basename = '%sdoc' % project
    if not config.latex_logo:
        config.latex_logo = os.path.relpath(os.path.join(STATIC_PATH, 'safari_logo.png'), config_dir)
    if not config.epub_title:
        config.epub_title = u'%s Documentation' % project
    if not config.epub_publisher:
        config.epub_publisher = config.epub_author
    if not config.epub_copyright:
        config.epub_copyright = config.copyright

    config.latex_documents.append(
        (master_doc,
         '%s.tex' % project,
         u'%s Documentation' % project,
         u'Safari',
         'manual'))
    config.man_pages.append(
        (master_doc,
         project,
         u'%s Documentation' % project,
         [u'Safari'],
         1))
    config.texinfo_documents.append(
        (master_doc,
         project,
         u'%s Documentation' % project,
         u'Safari',
         project,
         'One line description of project.',
         'Miscellaneous'))

    # Parse the version number from setup.py without actually running setup()
    with open(os.path.join(config_dir, '..', 'setup.py'), 'r') as f:
        content = f.read()
        match = re.search(r"version\s*=\s*['\"]([\d\.]+)['\"]", content)
        if match:
            config.version = match.group(1)
            config.release = config.version
414574
def _handle_changed_config(self, change):
        """"""

        key, value = change.get("key"), change.get("value")
        self.room.config.update({key: value})
        self.conn.enqueue_data("config", self.room.config)
251608
def change(self, key, value):
        """"""
        self.obj[key] = value
        self.changes.append("Updating build:{}.{}={}"
                            .format(self.obj['name'], key, value))
        return self
454485
private function updateStubsPathsInConfigFile()
    {
        $updated = str_replace('vendor/bpocallaghan/generators/', '',
            File::get($this->getConfigPath()));
        File::put($this->getConfigPath(), $updated);
    }