Updates this task whitelist on the saltant server.

        Returns:
            :class:`saltant.models.task_whitelist.TaskWhitelist`:
                A task whitelist model instance representing the task
                whitelist just updated.
19012
def put(self):
        
        return self.manager.put(
            id=self.id,
            name=self.name,
            description=self.description,
            whitelisted_container_task_types=(
                self.whitelisted_container_task_types
            ),
            whitelisted_executable_task_types=(
                self.whitelisted_executable_task_types
            ),
        )
1201248
def update_stack_list!
      if updater.nil? || !updater.alive?
        self.updater = Thread.new {
          loop do
            begin
              fetch_stacks
              sleep(stack_list_interval)
            rescue => e
              logger.error "Failure encountered on stack fetch: #{e.class} - #{e}"
            end
          end
        }
        true
      else
        false
      end
    end
660258
protected void updateAllServerList(List<T> ls) {
        // other threads might be doing this - in which case, we pass
        if (serverListUpdateInProgress.compareAndSet(false, true)) {
            try {
                for (T s : ls) {
                    s.setAlive(true); // set so that clients can start using these
                                      // servers right away instead
                                      // of having to wait out the ping cycle.
                }
                setServersList(ls);
                super.forceQuickPing();
            } finally {
                serverListUpdateInProgress.set(false);
            }
        }
    }
896497
def add_terms_to_whitelist(self, terms):
        

        resp = self._client.post("whitelist", json=terms)
        return [Indicator.from_dict(indicator) for indicator in resp.json()]
450269
def update(self, friendly_name):
        
        data = values.of({'FriendlyName': friendly_name, })

        payload = self._version.update(
            'POST',
            self._uri,
            data=data,
        )

        return FunctionInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            sid=self._solution['sid'],
        )
1356555
def update_subtask(self, subtask_id, revision, title=None, completed=None):
        '''
        
        '''
        return subtasks_endpoint.update_subtask(self, subtask_id, revision, title=title, completed=completed)
622526
def update_current_taskset(taskset)
      if taskset.present?
        RRRSpec.redis.hset(key, 'taskset', taskset.key)
      else
        RRRSpec.redis.hset(key, 'taskset', nil)
      end
    end
960165
def asset_taskfile_sel_changed(self, tf):
        
        self.asset_open_pb.setEnabled(bool(tf))
        # only allow new, when there is an asset. if there is an asset, there should always be a task
        enablenew = bool(self.browser.assetbrws.selected_indexes(1)) and self.browser.get_releasetype() == djadapter.RELEASETYPES['work']
        self.asset_save_pb.setEnabled(enablenew)
        self.asset_descriptor_le.setEnabled(enablenew)
        self.asset_comment_pte.setEnabled(enablenew)
        self.update_descriptor_le(self.asset_descriptor_le, tf)
510190
def update(self, **kwargs):
        
        if 'useProxyServer' in kwargs and kwargs['useProxyServer'] == 'enabled':
            if 'proxyServerPool' not in kwargs:
                error = 'Missing proxyServerPool parameter value.'
                raise MissingUpdateParameter(error)
        if hasattr(self, 'useProxyServer'):
            if getattr(self, 'useProxyServer') == 'enabled' and 'proxyServerPool' not in self.__dict__:
                error = 'Missing proxyServerPool parameter value.'
                raise MissingUpdateParameter(error)

        self._update(**kwargs)

        return self
56280
def update_tasks(self):
        """"""
        for task in self.task_manager.timeout_tasks():
            self.task_manager.task_done(
                task.id, TimeoutError("Task timeout", task.timeout))
            self.worker_manager.stop_worker(task.worker_id)

        for task in self.task_manager.cancelled_tasks():
            self.task_manager.task_done(
                task.id, CancelledError())
            self.worker_manager.stop_worker(task.worker_id)
859508
def update(self, display_name=None, display_description=None):
        
        return self.manager.update(self, display_name=display_name,
                display_description=display_description)
638081
def refresh(
            self):
        

        if self.parent:
            self.parent.refresh

        replace = None
        title = self.title
        for t in self.parent.tasks:
            if t.title == title:
                replace = t
        if not replace:
            return

        self.tags = replace.tags

        self.notes = replace.notes
        self.tasks = replace.tasks

        self.content = replace.to_string(indentLevel=0, title=False)

        return None
1210558
def update_tasks_task
      require 'net/https'
      require 'uri'
      
      uri = URI.parse('https://raw.github.com/wvanbergen/github-gem/master/tasks/github-gem.rake')
      http = Net::HTTP.new(uri.host, uri.port)
      http.use_ssl = true
      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
      response = http.request(Net::HTTP::Get.new(uri.path))

      if Net::HTTPSuccess === response
        open(__FILE__, "w") { |file| file.write(response.body) }
        relative_file = File.expand_path(__FILE__).sub(%r[^#{@root_dir}/], '')
        if `#{git} ls-files -m #{relative_file}`.split("\n").any?
          sh git, 'add', relative_file
          sh git, 'commit', '-m', "Updated to latest gem release management tasks."
        else
          puts "Release managament tasks already are at the latest version."
        end
      else
        raise "Download failed with HTTP status #{response.code}!"
      end
    end
543732
def get_tasks_changed_since(self, since):
        
        changed_tasks = []

        for task in self.client.filter_tasks({'status': 'pending'}):
            if task.get(
                'modified',
                task.get(
                    'entry',
                    datetime.datetime(2000, 1, 1).replace(tzinfo=pytz.utc)
                )
            ) >= since:
                changed_tasks.append(task)

        return changed_tasks
522650
def _update_task(self, task):
        
        self.task = task
        self.task.data.update(self.task_data)
        self.task_type = task.task_spec.__class__.__name__
        self.spec = task.task_spec
        self.task_name = task.get_name()
        self.activity = getattr(self.spec, 'service_class', '')
        self._set_lane_data()
859409
def mark_resolved(task_id):
    
    from . import models
    models.FailedTask.objects.filter(task_id=task_id, datetime_resolved=None).update(datetime_resolved=now())
1039452
def UpdateTaskAsPendingMerge(self, task):
    
    with self._lock:
      is_abandoned = task.identifier in self._tasks_abandoned
      is_processing = task.identifier in self._tasks_processing
      is_queued = task.identifier in self._tasks_queued

      if not is_queued and not is_processing and not is_abandoned:
        raise KeyError('Status of task {0:s} is unknown.'.format(
            task.identifier))

      if is_abandoned and task.has_retry:
        raise KeyError('Will not merge a task {0:s} with retry task.'.format(
            task.identifier))

      if is_queued:
        logger.debug('Task {0:s} was queued, now merging.'.format(
            task.identifier))
        del self._tasks_queued[task.identifier]

      if is_processing:
        logger.debug('Task {0:s} was processing, now merging.'.format(
            task.identifier))
        del self._tasks_processing[task.identifier]

      if is_abandoned:
        logger.debug('Task {0:s} was abandoned, now merging.'.format(
            task.identifier))
        del self._tasks_abandoned[task.identifier]

      self._tasks_pending_merge.PushTask(task)

      self.SampleTaskStatus(task, 'pending_merge')

      task.UpdateProcessingTime()
      self._UpdateLatestProcessingTime(task)