Executes the rrdtool update command.
510548
protected void rrdToolUpdate(String template, String data) throws Exception {
		List<String> commands = new ArrayList<>();
		commands.add(binaryPath + "/rrdtool");
		commands.add("update");
		commands.add(outputFile.getCanonicalPath());
		commands.add("-t");
		commands.add(template);
		commands.add("N:" + data);

		ProcessBuilder pb = new ProcessBuilder(commands);
		Process process = pb.start();
		checkErrorStream(process);
	}
706754
public function update()
    {
        try {
            Option::set(self::LAST_RUN_TIME_OPTION_NAME, Date::factory('today')->getTimestamp());

            $locUrl = Option::get(self::LOC_URL_OPTION_NAME);
            if (!empty($locUrl)) {
                $this->downloadFile('loc', $locUrl);
            }

            $ispUrl = Option::get(self::ISP_URL_OPTION_NAME);
            if (!empty($ispUrl)) {
                $this->downloadFile('isp', $ispUrl);
            }
        } catch (Exception $ex) {
            // message will already be prefixed w/ 'GeoIP2AutoUpdater: '
            Log::error($ex);
            $this->performRedundantDbChecks();
            throw $ex;
        }

        $this->performRedundantDbChecks();
    }
599907
def perform_update(self, data, instance):
        

        for key, val in data.items():
            setattr(instance, key, val)
854842
def refresh_db(**kwargs):
    '''
    
    '''
    # Remove rtag file to keep multiple refreshes from happening in pkg states
    salt.utils.pkg.clear_rtag(__opts__)
    cmd = 'update'
    if _call_brew(cmd)['retcode']:
        log.error('Failed to update')
        return False

    return True
1173582
public void update() throws RedmineException {
        String urlSafeTitle = getUrlSafeString(getTitle());
        transport.updateChildEntry(Project.class, getProjectKey(), this, urlSafeTitle);
    }
1050942
def update(self):
        """"""
        for linenum in reversed(sorted(self.updates)):
            self.replace_baseline_repr(linenum, self.updates[linenum])

        if not self.TEST_MODE:
            path = '{}.update{}'.format(*os.path.splitext(self.path))
            with io.open(path, 'w', encoding='utf-8') as fh:
                fh.write('\n'.join(self.lines))
            print('UPDATE: {}'.format(self.showpath(path)))
880451
def run(self):
        """"""
        while True:
            try:
                self.perform_iteration()
            except Exception:
                traceback.print_exc()
                pass

            time.sleep(ray_constants.REPORTER_UPDATE_INTERVAL_MS / 1000)
703915
def update_all(self, rs=None, since=None):
        ""
        self._log.info("Updating resources: %s", ' '.join(r.tag for r in rs))

        if rs is None:
            rs = resource.all_resources()
        ctx = self._ContextClass(self)
        for r in rs:
            self._atomic_update(lambda: ctx.sync_resource(r, since=since))
1019389
async def execute_command(self, command):
        """"""
        self.apply_future = asyncio.Future(loop=self.loop)

        entry = self.log.write(self.storage.term, command)
        asyncio.ensure_future(self.append_entries(), loop=self.loop)

        await self.apply_future
196718
public void execute() throws IOException
   {
      // Future todo: Use JNI and librsync library?
      Runtime run = Runtime.getRuntime();
      try
      {
         String command ;
         if(excludeDir != null && !excludeDir.isEmpty())
         {
            command= "rsync -rv --delete --exclude "+ excludeDir + " " + src + " " + dst;
         }
         else
         {
            command= "rsync -rv --delete " + src + " " + dst;
         }

         if (LOG.isDebugEnabled())
         {
            LOG.debug("Rsync job started: " + command);
         }
         if (userName != null && password != null)
         {
            String[] envProperties =
               new String[]{RSYNC_USER_SYSTEM_PROPERTY + "=" + userName,
                  RSYNC_PASSWORD_SYSTEM_PROPERTY + "=" + password};
            process = run.exec(command, envProperties);
         }
         else
         {
            process = run.exec(command);
         }

         // Handle process Standard and Error output
         InputStream stderr = process.getErrorStream();
         InputStreamReader isrErr = new InputStreamReader(stderr);
         BufferedReader brErr = new BufferedReader(isrErr);

         InputStream stdout = process.getInputStream();
         InputStreamReader isrStd = new InputStreamReader(stdout);
         BufferedReader brStd = new BufferedReader(isrStd);

         String val = null;
         StringBuilder stringBuilderErr = new StringBuilder();
         StringBuilder stringBuilderStd = new StringBuilder();
         while ((val = brStd.readLine()) != null)
         {
            stringBuilderStd.append(val);
            stringBuilderStd.append('\n');
         }

         while ((val = brErr.readLine()) != null)
         {
            stringBuilderErr.append(val);
            stringBuilderErr.append('\n');
         }

         Integer returnCode = null;
         // wait for thread
         while (returnCode == null)
         {
            try
            {
               returnCode = process.waitFor();
            }
            catch (InterruptedException e)
            {
               // oops, this can happen sometimes
            }
         }
         if (LOG.isDebugEnabled())
         {
            LOG.debug("Rsync job finished: " + returnCode + ". Error stream output \n"
               + stringBuilderErr.toString() + " Standard stream output \n" + stringBuilderStd.toString());
         }
         if (returnCode != 0)
         {
            throw new IOException("RSync job finished with exit code is " + returnCode + ". Error stream output: \n"
               + stringBuilderErr.toString());
         }
      }
      finally
      {
         process = null;
      }
   }
464838
private void scheduleUpdate() {
		if (!isVisible()) {
			return;
		}
		
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				try {
					container.gameLoop();
				} catch (SlickException e) {
					e.printStackTrace();
				}
				container.checkDimensions();
				scheduleUpdate();
			}
		});
	}
611280
def update(self,record,**kw):
        """"""
        vals = self._make_sql_params(kw)
        sql = "UPDATE %s SET %s WHERE rowid=?" %(self.name,
            ",".join(vals))
        self.cursor.execute(sql,kw.values()+[record['__id__']])
766472
@Override
	public void update () {
		// Execute the global state (if any)
		if (globalState != null) globalState.update(owner);

		// Execute the current state (if any)
		if (currentState != null) currentState.update(owner);
	}
934420
public function execute()
    {
        $response = $this->client->allDocs(100);
        $lastKey = null;

        do {
            if ($response->status !== 200) {
                throw new \RuntimeException('Error while migrating at offset '.$offset);
            }

            $bulkUpdater = $this->client->createBulkUpdater();
            foreach ($response->body['rows'] as $row) {
                $doc = $this->migrate($row['doc']);
                if ($doc) {
                    $bulkUpdater->updateDocument($doc);
                }
                $lastKey = $row['key'];
            }

            $bulkUpdater->execute();
            $response = $this->client->allDocs(100, $lastKey);
        } while (count($response->body['rows']) > 1);
    }
829958
def runRemoteCommand(self, cmd, args, abandonOnFailure=True,
                         evaluateCommand=lambda cmd: cmd.didFail()):
        """"""
        cmd = remotecommand.RemoteCommand(cmd, args)
        if hasattr(self, "rc_log"):
            cmd.useLog(self.rc_log, False)
        d = self.runCommand(cmd)

        def commandComplete(cmd):
            if abandonOnFailure and cmd.didFail():
                raise buildstep.BuildStepFailed()
            return evaluateCommand(cmd)

        d.addCallback(lambda res: commandComplete(cmd))
        return d
308064
def do_command(self):
        """"""
        method = self.args[0]

        raw_args = self.args[1:]
        if '=' in method:
            if raw_args:
                self.parser.error("Please don't mix rTorrent and shell argument styles!")
            method, raw_args = method.split('=', 1)
            raw_args = raw_args.split(',')

        self.execute(self.open(), method, self.cooked(raw_args))
1209515
def update(self):
        
        def process_result(result):
            self.raw = result
        return Command('get', self.path, process_result=process_result)