Save Config for Extreme SLX.
547493
def save_config(
        self,
        cmd="copy running-config startup-config",
        confirm=True,
        confirm_response="y",
    ):
        """"""
        return super(ExtremeSlxSSH, self).save_config(
            cmd=cmd, confirm=confirm, confirm_response=confirm_response
        )
584396
def configure(self, ext):
        """"""
        ext.include_dirs += self.include_dirs
        ext.library_dirs += self.library_dirs
        ext.libraries += self.libraries
        ext.extra_compile_args += self.extra_compile_args
        ext.extra_link_args += self.extra_link_args
        ext.extra_objects += self.extra_objects
1079758
def save_config(self, cmd="save config flash", confirm=False, confirm_response=""):
        """"""
        return super(MrvOptiswitchSSH, self).save_config(
            cmd=cmd, confirm=confirm, confirm_response=confirm_response
        )
808595
def store_config(config, suffix = None):
    '''
    
    '''
    home = os.path.expanduser('~')
    if suffix is not None:
        config_path = os.path.join(home, '.transfer', suffix)
    else:
        config_path = os.path.join(home, '.transfer')

    os.makedirs(config_path, exist_ok = True)
    with open(os.path.join(config_path, 'config.yaml'), 'w') as fp:
        yaml.dump(config, fp)
594988
def save_config(self, lookup_key, config):
    
    with self._config_lock:
      self._configs[lookup_key] = config
424359
def save_config(self):
        
        if not os.path.exists(self._conf_dir):
            os.makedirs(self._conf_dir)
        conf_file = os.path.join(self._conf_dir, "dql.json")
        with open(conf_file, "w") as ofile:
            json.dump(self.conf, ofile, indent=2)
373318
def persist_config(run, session, cfg):
    
    from benchbuild.utils import schema as s

    for cfg_elem in cfg:
        session.add(
            s.Config(name=cfg_elem, value=cfg[cfg_elem], run_id=run.id))
202821
def configure(self, options, conf):
        
        super(EverestNosePlugin, self).configure(options, conf)
        opt_val = getattr(options, self.__dest_opt_name, None)
        if opt_val:
            self.enabled = True
            EverestIni.ini_file_path = opt_val
69049
def _set_save_states(self):
        """"""

        wx.BeginBusyCursor()
        self.saving = True
        self.grid.Disable()
1276269
def _write_config(self):
        """"""

        if not self.config:
            self.log("Unable to write non existing configuration", lvl=error)
            return

        self.config.save()
        self.log("Configuration stored.")
546417
def saveConfig(self, request):
        """"""
        res = yield self.assertAllowed(request)
        if res:
            defer.returnValue(res)
        request.setHeader('Content-Type', 'application/json')
        if self._in_progress:
            defer.returnValue(json.dumps({'success': False, 'errors': ['reconfig already in progress']}))
        self._in_progress = True
        cfg = json.loads(request.content.read())
        if cfg != self._cfg:
            try:
                err = yield self.saveCfg(cfg)
            except Exception as e:  # noqa
                err = [repr(e)]
            if err is not None:
                self._in_progress = False
                yield self.saveCfg(self._cfg)
                defer.returnValue(json.dumps({'success': False, 'errors': err}))

        yield self.ep.master.reconfig()
        defer.returnValue(json.dumps({'success': True}))
1276546
def config(ctx):
    """"""

    from hfos import database
    database.initialize(ctx.obj['dbhost'], ctx.obj['dbname'])

    from hfos.schemata.component import ComponentConfigSchemaTemplate
    ctx.obj['col'] = model_factory(ComponentConfigSchemaTemplate)
276177
def save_config(self, cmd="write memory", confirm=False, confirm_response=""):
        """"""
        return super(UbiquitiEdgeSSH, self).save_config(
            cmd=cmd, confirm=confirm, confirm_response=confirm_response
        )
15595
def save_default_values(self):
        """"""
        for parameter_container in self.default_value_parameter_containers:
            parameters = parameter_container.get_parameters()
            for parameter in parameters:
                set_inasafe_default_value_qsetting(
                    self.settings,
                    GLOBAL,
                    parameter.guid,
                    parameter.value
                )
544546
def save(self):
        
        cfg_file = "/etc/nago/nago.ini"
        config = ConfigParser.ConfigParser()
        config.read(cfg_file)
        result = {}
        token = self.data.pop("token", self.token)
        if token != self._original_token:
            config.remove_section(self._original_token)
            config.add_section(token)

        if token not in config.sections():
            config.add_section(token)
        for key, value in self.data.items():
            config.set(token, key, value)
        for key, value in config.items(token):
            if key not in self.data:
                config.set(token, key, None)
        with open(cfg_file, 'w') as f:
            return config.write(f)
1209622
def save(self, filename, verbose=False):
        
        with open(filename, 'w') as fid:
            json.dump(self._conf, fid, indent=4)
        if verbose:
            print('Saved settings in ' + filename)
220436
def save(dir = Dir.pwd, config = {}, type = :local, options = {})
      conffile = config_file(dir, type, options)
      confdir  = File.dirname( conffile )
      unless File.directory?( confdir )
        warning "about to create the configuration directory #{confdir}"
        really_continue?  unless options[:no_interaction]
        run %( mkdir -p #{confdir} )
      end
      store_config(conffile, config, options)
    end