Use this API to restore systembackup.
498420
public static base_response restore(nitro_service client, systembackup resource) throws Exception {
		systembackup restoreresource = new systembackup();
		restoreresource.filename = resource.filename;
		return restoreresource.perform_operation(client,"restore");
	}
1331326
private function restoreBackup()
    {
        $hash       = $this->getHash();
        $connection = $this->entityManager->getConnection();

        $this->backupService->restoreBackup($connection, $hash);
    }
1138885
def restore_backup(self, subid, backupid, params=None):
        ''' 
        '''
        params = update_params(params, {
            'SUBID': subid,
            'BACKUPID': backupid
        })
        return self.request('/v1/server/restore_backup', params, 'POST')
919628
private function restore() {
        if (!HTTPCookie::exists($this->name)) return (object)[];
        
        return json_decode(Text::unlock(HTTPCookie::get($this->name)));
    }
728904
def get_restored(self):
        """"""
        return self._header.initial.restore_time > 0, self._header.initial.restore_time
102078
final protected void restore() throws Throwable
   {
      try
      {
         stateRestore = RESTORE_STARTED;
         startTime = Calendar.getInstance();

         restoreWorkspace();

         stateRestore = RESTORE_SUCCESSFUL;
         endTime = Calendar.getInstance();
      }
      catch (Throwable t) //NOSONAR
      {
         stateRestore = RESTORE_FAIL;
         restoreException = t;

         throw new RepositoryRestoreExeption(t.getMessage(), t);
      }
   }
1129658
def restore_state(self):
        """"""
        last_path = setting('directory', '', expected_type=str)
        self.output_directory.setText(last_path)
226552
public void restoreAfterSafeModeRestart() throws IOException {
    if (!clusterManager.safeMode) {
      throw new IOException("restoreAfterSafeModeRestart() called while the " +
        "Cluster Manager was not in Safe Mode");
    }
    // Restoring all the ClusterNode(s)
    for (ClusterNode clusterNode : nameToNode.values()) {
      restoreClusterNode(clusterNode);
    }

    // Restoring all the RequestedNodes(s)
    for (ClusterNode clusterNode : nameToNode.values()) {
      for (ResourceRequestInfo resourceRequestInfo :
        clusterNode.grants.values()) {
        // Fix the RequestedNode(s)
        restoreResourceRequestInfo(resourceRequestInfo);
        loadManager.incrementLoad(resourceRequestInfo.getType());
      }
    }
  }
1181566
def restore(self):
        """"""
        if not self._snapshot:
            return
        yield from self.set_name(self._snapshot['name'])
        yield from self.set_volume(self._snapshot['volume'])
        yield from self.set_muted(self._snapshot['muted'])
        yield from self.set_latency(self._snapshot['latency'])
        self.callback()
        _LOGGER.info('restored snapshot of state of %s', self.friendly_name)
1280887
void backup() throws ConfigurationPersistenceException {
        if (!doneBootup.get()) {
            return;
        }
        try {
            if (!interactionPolicy.isReadOnly()) {
                //Move the main file to the versioned history
                moveFile(mainFile, getVersionedFile(mainFile));
            } else {
                //Copy the Last file to the versioned history
                moveFile(lastFile, getVersionedFile(mainFile));
            }
            int seq = sequence.get();
            // delete unwanted backup files
            int currentHistoryLength = getInteger(CURRENT_HISTORY_LENGTH_PROPERTY, CURRENT_HISTORY_LENGTH, 0);
            if (seq > currentHistoryLength) {
                for (int k = seq - currentHistoryLength; k > 0; k--) {
                    File delete = getVersionedFile(mainFile, k);
                    if (! delete.exists()) {
                        break;
                    }
                    delete.delete();
                }
            }
        } catch (IOException e) {
            throw ControllerLogger.ROOT_LOGGER.failedToBackup(e, mainFile);
        }
    }
641853
public function restorePlugin()
    {
        (new Filesystem())->mirror($this->backupDir, $this->plugin->directory, null, ['delete' => true, 'override' => true]);
    }
1305220
public void restore() {

        if (!restored) {

            // Remove the extra Handler from the RootLogger
            rootLogger.removeHandler(mavenLogHandler);

            // Restore the original state to the Root logger
            rootLogger.setLevel(originalRootLoggerLevel);
            for (Handler current : originalHandlers) {
                rootLogger.addHandler(current);
            }

            // All done.
            restored = true;
        }
    }
1050976
public function restore()
	{
		$this->master->params()->rollback();
		$this->slave->params()->rollback();

		// We should also save these so we know any changes have been fully reversed
		$this->master->save();
		$this->slave->save();
	}
729822
def restore_from_snapshot(self, volume_id, snapshot_id):
        

        return self.client.call('Network_Storage', 'restoreFromSnapshot',
                                snapshot_id, id=volume_id)
980611
public static systembackup[] get(nitro_service service, options option) throws Exception{
		systembackup obj = new systembackup();
		systembackup[] response = (systembackup[])obj.get_resources(service,option);
		return response;
	}
1009865
final protected void restore() throws RepositoryRestoreExeption
   {
      try
      {
         stateRestore = REPOSITORY_RESTORE_STARTED;
         startTime = Calendar.getInstance();

         restoreRepository();

         stateRestore = REPOSITORY_RESTORE_SUCCESSFUL;
         endTime = Calendar.getInstance();
      }
      catch (Throwable t) //NOSONAR
      {
         stateRestore = REPOSITORY_RESTORE_FAIL;
         restoreException = t;

         throw new RepositoryRestoreExeption(t.getMessage(), t);
      }
      finally
      {
         if (removeJobOnceOver)
         {
            backupManager.restoreRepositoryJobs.remove(this);
         }  
      }
   }
1064220
public static sdx_backup_restore restore(nitro_service client, sdx_backup_restore resource) throws Exception
	{
		return ((sdx_backup_restore[]) resource.perform_operation(client, "restore"))[0];
	}