Create a ReservationUpdater to execute update.

@param pathWorkspaceSid The workspace_sid
@param pathWorkerSid The worker_sid
@param pathSid The sid
@return ReservationUpdater capable of executing the update
174653
public static ReservationUpdater updater(final String pathWorkspaceSid, 
                                             final String pathWorkerSid, 
                                             final String pathSid) {
        return new ReservationUpdater(pathWorkspaceSid, pathWorkerSid, pathSid);
    }
364465
public void setGroupsForPath(Integer[] groups, int pathId) {
        String newGroups = Arrays.toString(groups);
        newGroups = newGroups.substring(1, newGroups.length() - 1).replaceAll("\\s", "");

        logger.info("adding groups={}, to pathId={}", newGroups, pathId);
        EditService.updatePathTable(Constants.PATH_PROFILE_GROUP_IDS, newGroups, pathId);
    }
480416
public static ExecutionStepContextFetcher fetcher(final String pathFlowSid, 
                                                      final String pathExecutionSid, 
                                                      final String pathStepSid) {
        return new ExecutionStepContextFetcher(pathFlowSid, pathExecutionSid, pathStepSid);
    }
5105
private void sendUpdatePartitionInfoRpcCall(
			final Iterable<PartitionInfo> partitionInfos) {

		final LogicalSlot slot = assignedResource;

		if (slot != null) {
			final TaskManagerGateway taskManagerGateway = slot.getTaskManagerGateway();
			final TaskManagerLocation taskManagerLocation = slot.getTaskManagerLocation();

			CompletableFuture<Acknowledge> updatePartitionsResultFuture = taskManagerGateway.updatePartitions(attemptId, partitionInfos, rpcTimeout);

			updatePartitionsResultFuture.whenCompleteAsync(
				(ack, failure) -> {
					// fail if there was a failure
					if (failure != null) {
						fail(new IllegalStateException("Update task on TaskManager " + taskManagerLocation +
							" failed due to:", failure));
					}
				}, getVertex().getExecutionGraph().getJobMasterMainThreadExecutor());
		}
	}
433563
@RequestMapping(value = "", method = RequestMethod.POST)
    public String pathOrderUpdated(Model model, @PathVariable int profileId, String pathOrder) {

        logger.info("new path order = {}", pathOrder);
        int[] intArrayPathOrder = Utils.arrayFromStringOfIntegers(pathOrder);
        pathOverrideService.updatePathOrder(profileId, intArrayPathOrder);

        return "pathOrder";
    }
1246060
public static StreamMessageCreator creator(final String pathServiceSid, 
                                               final String pathStreamSid, 
                                               final Map<String, Object> data) {
        return new StreamMessageCreator(pathServiceSid, pathStreamSid, data);
    }
824581
public static WorkerChannelFetcher fetcher(final String pathWorkspaceSid, 
                                               final String pathWorkerSid, 
                                               final String pathSid) {
        return new WorkerChannelFetcher(pathWorkspaceSid, pathWorkerSid, pathSid);
    }
521231
@Nullable
  private MasterWorkerInfo registerWorkerInternal(long workerId) {
    for (IndexedSet<MasterWorkerInfo> workers: Arrays.asList(mTempWorkers, mLostWorkers)) {
      MasterWorkerInfo worker = workers.getFirstByField(ID_INDEX, workerId);
      if (worker == null) {
        continue;
      }

      synchronized (worker) {
        worker.updateLastUpdatedTimeMs();
        mWorkers.add(worker);
        workers.remove(worker);
        if (workers == mLostWorkers) {
          for (Consumer<Address> function : mLostWorkerFoundListeners) {
            function.accept(new Address(worker.getWorkerAddress().getHost(),
                  worker.getWorkerAddress().getRpcPort()));
          }
          LOG.warn("A lost worker {} has requested its old id {}.",
              worker.getWorkerAddress(), worker.getId());
        }
      }

      return worker;
    }
    return null;
  }
1091626
public static VariableFetcher fetcher(final String pathServiceSid, 
                                          final String pathEnvironmentSid, 
                                          final String pathSid) {
        return new VariableFetcher(pathServiceSid, pathEnvironmentSid, pathSid);
    }
554409
public static SyncMapItemFetcher fetcher(final String pathServiceSid, 
                                             final String pathMapSid, 
                                             final String pathKey) {
        return new SyncMapItemFetcher(pathServiceSid, pathMapSid, pathKey);
    }
579405
public static AssetVersionFetcher fetcher(final String pathServiceSid, 
                                              final String pathAssetSid, 
                                              final String pathSid) {
        return new AssetVersionFetcher(pathServiceSid, pathAssetSid, pathSid);
    }
690623
public void putWorkspace(long workspaceId, Workspace workspace) throws StructurizrClientException {
        if (workspace == null) {
            throw new IllegalArgumentException("The workspace must not be null.");
        } else if (workspaceId <= 0) {
            throw new IllegalArgumentException("The workspace ID must be a positive integer.");
        }

        try (CloseableHttpClient httpClient = HttpClients.createSystem()) {
            if (mergeFromRemote) {
                Workspace remoteWorkspace = getWorkspace(workspaceId);
                if (remoteWorkspace != null) {
                    workspace.getViews().copyLayoutInformationFrom(remoteWorkspace.getViews());
                    workspace.getViews().getConfiguration().copyConfigurationFrom(remoteWorkspace.getViews().getConfiguration());
                }
            }

            workspace.setId(workspaceId);
            workspace.setThumbnail(null);
            workspace.setLastModifiedDate(new Date());
            workspace.setLastModifiedAgent(STRUCTURIZR_FOR_JAVA_AGENT);
            workspace.setLastModifiedUser(getUser());

            workspace.countAndLogWarnings();

            HttpPut httpPut = new HttpPut(url + WORKSPACE_PATH + workspaceId);

            StringWriter stringWriter = new StringWriter();
            if (encryptionStrategy == null) {
                JsonWriter jsonWriter = new JsonWriter(false);
                jsonWriter.write(workspace, stringWriter);
            } else {
                EncryptedWorkspace encryptedWorkspace = new EncryptedWorkspace(workspace, encryptionStrategy);
                encryptionStrategy.setLocation(EncryptionLocation.Client);
                EncryptedJsonWriter jsonWriter = new EncryptedJsonWriter(false);
                jsonWriter.write(encryptedWorkspace, stringWriter);
            }

            StringEntity stringEntity = new StringEntity(stringWriter.toString(), ContentType.APPLICATION_JSON);
            httpPut.setEntity(stringEntity);
            addHeaders(httpPut, EntityUtils.toString(stringEntity), ContentType.APPLICATION_JSON.toString());

            debugRequest(httpPut, EntityUtils.toString(stringEntity));

            log.info("Putting workspace with ID " + workspaceId);
            try (CloseableHttpResponse response = httpClient.execute(httpPut)) {
                String json = EntityUtils.toString(response.getEntity());
                if (response.getCode() == HttpStatus.SC_OK) {
                    debugResponse(response);
                    log.info(json);
                } else {
                    ApiResponse apiResponse = ApiResponse.parse(json);
                    throw new StructurizrClientException(apiResponse.getMessage());
                }
            }
        } catch (Exception e) {
            log.error(e);
            throw new StructurizrClientException(e);
        }
    }
767467
public void localUpdateLongRunningFree(Address logicalAddress, Long freeCount)
   {
      if (trace)
         log.tracef("LOCAL_UPDATE_LONGRUNNING_FREE(%s, %d)", logicalAddress, freeCount);

      DistributedWorkManager dwm = workManagerCoordinator.resolveDistributedWorkManager(logicalAddress);

      if (dwm != null)
      {
         Collection<NotificationListener> copy =
            new ArrayList<NotificationListener>(dwm.getNotificationListeners());
         for (NotificationListener nl : copy)
         {
            nl.updateLongRunningFree(logicalAddress, freeCount);
         }
      }
      else
      {
         WorkManagerEventQueue wmeq = WorkManagerEventQueue.getInstance();
         wmeq.addEvent(new WorkManagerEvent(WorkManagerEvent.TYPE_UPDATE_LONG_RUNNING, logicalAddress, freeCount));
      }
   }
994195
public void setName(int pathId, String pathName) {
        PreparedStatement statement = null;
        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "UPDATE " + Constants.DB_TABLE_PATH +
                    " SET " + Constants.PATH_PROFILE_PATHNAME + " = ?" +
                    " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setString(1, pathName);
            statement.setInt(2, pathId);
            statement.executeUpdate();
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
    }
667693
public function updateWorkspace($workspaceId = null, $data = ["name" => ""])
    {
        $workspaceId = $workspaceId ?: $this->defaultWorkspaceId;

        return $this->curl->put("workspaces/{$workspaceId}", ['data' => $data]);
    }
1373172
public function resourceWorkspace($workspaceId)
    {
        if (!$this->request) {
            throw new NoHttpRequestException();
        }

        $breadcrumbsIds = $this->request->query->get('_breadcrumbs');

        if ($breadcrumbsIds != null) {
            $ancestors = $this->manager->getByIds($breadcrumbsIds);

            if (!$this->manager->isPathValid($ancestors)) {
                throw new \Exception('Breadcrumbs invalid');
            };
        } else {
            $ancestors = array();
        }
        $path = array();

        foreach ($ancestors as $ancestor) {
            $path[] = $this->manager->toArray($ancestor, $this->tokenStorage->getToken());
        }

        $jsonPath = json_encode($path);

        $workspace = $this->workspaceManager->getWorkspaceById($workspaceId);
        $directoryId = $this->resourceManager->getWorkspaceRoot($workspace)->getId();
        $resourceTypes = $this->em->getRepository('ClarolineCoreBundle:Resource\ResourceType')
            ->findAll();
        $resourceActions = $this->em->getRepository('ClarolineCoreBundle:Resource\MenuAction')
            ->findByResourceType(null);

        return $this->templating->render(
            'ClarolineCoreBundle:Tool\workspace\resource_manager:resources.html.twig', array(
                'workspace' => $workspace,
                'directoryId' => $directoryId,
                'resourceTypes' => $resourceTypes,
                'resourceActions' => $resourceActions,
                'jsonPath' => $jsonPath,
                'maxPostSize' => ini_get('post_max_size'),
                'resourceZoom' => $this->getZoom()
             )
        );
    }
415337
public static ReservationFetcher fetcher(final String pathWorkspaceSid, 
                                             final String pathWorkerSid, 
                                             final String pathSid) {
        return new ReservationFetcher(pathWorkspaceSid, pathWorkerSid, pathSid);
    }