signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def getArtifact(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Artifact from Run
Get artifact by `<name>` from a specific run.
**Public Artifacts**, in-order to get an artifact you need the scope
`queue:get-artifact:<name>`, where `<name>` is the name of the artifact.
But if the artifact `name` starts with `public/`, authentication and
authorization is not necessary to fetch... | f15732:c0:m18 |
def listArtifacts(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Artifacts from Run
Returns a list of artifacts and associated meta-data for a given run.
As a task may have many artifacts paging may be necessary. If this
end-point returns a `continuationToken`, you should call the end-point
again with the `continuationToken` as the query-string option:
`continuationToken`.
By... | f15732:c0:m20 |
def listProvisioners(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a list of all active provisioners
Get all active provisioners.
The term "provisioner" is taken broadly to mean anything with a provisionerId.
This does not necessarily mean there is an associated service performing any
provisioning activity.
The response is paged. If this end-point returns a `continuationToken`,... | f15732:c0:m22 |
def getProvisioner(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get an active provisioner
Get an active provisioner.
The term "provisioner" is taken broadly to mean anything with a provisionerId.
This does not necessarily mean there is an associated service performing any
provisioning activity.
This method gives output: ``v1/provisioner-response.json#``
This method is ``experim... | f15732:c0:m23 |
def declareProvisioner(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Update a provisioner
Declare a provisioner, supplying some details about it.
`declareProvisioner` allows updating one or more properties of a provisioner as long as the required scopes are
possessed. For example, a request to update the `aws-provisioner-v1`
provisioner with a body `{description: 'This provisioner is ... | f15732:c0:m24 |
def pendingTasks(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Number of Pending Tasks
Get an approximate number of pending tasks for the given `provisionerId`
and `workerType`.
The underlying Azure Storage Queues only promises to give us an estimate.
Furthermore, we cache the result in memory for 20 seconds. So consumers
should be no means expect this to be an accurate numb... | f15732:c0:m25 |
def listWorkerTypes(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a list of all active worker-types
Get all active worker-types for the given provisioner.
The response is paged. If this end-point returns a `continuationToken`, you
should call the end-point again with the `continuationToken` as a query-string
option. By default this end-point will list up to 1000 worker-types in... | f15732:c0:m26 |
def getWorkerType(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a worker-type
Get a worker-type from a provisioner.
This method gives output: ``v1/workertype-response.json#``
This method is ``experimental`` | f15732:c0:m27 |
def declareWorkerType(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Update a worker-type
Declare a workerType, supplying some details about it.
`declareWorkerType` allows updating one or more properties of a worker-type as long as the required scopes are
possessed. For example, a request to update the `gecko-b-1-w2008` worker-type within the `aws-provisioner-v1`
provisioner with a bo... | f15732:c0:m28 |
def listWorkers(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a list of all active workers of a workerType
Get a list of all active workers of a workerType.
`listWorkers` allows a response to be filtered by quarantined and non quarantined workers.
To filter the query, you should call the end-point with `quarantined` as a query-string option with a
true or false value.
The ... | f15732:c0:m29 |
def getWorker(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a worker-type
Get a worker from a worker-type.
This method gives output: ``v1/worker-response.json#``
This method is ``experimental`` | f15732:c0:m30 |
def quarantineWorker(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Quarantine a worker
Quarantine a worker
This method takes input: ``v1/quarantine-worker-request.json#``
This method gives output: ``v1/worker-response.json#``
This method is ``experimental`` | f15732:c0:m31 |
def declareWorker(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Declare a worker
Declare a worker, supplying some details about it.
`declareWorker` allows updating one or more properties of a worker as long as the required scopes are
possessed.
This method takes input: ``v1/update-worker-request.json#``
This method gives output: ``v1/worker-response.json#``
This method is ``ex... | f15732:c0:m32 |
def ping(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Ping Server
Respond without doing anything.
This endpoint is used to check that the service is up.
This method is ``stable`` | f15733:c0:m0 |
def githubWebHookConsumer(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Consume GitHub WebHook
Capture a GitHub event and publish it via pulse, if it's a push,
release or pull request.
This method is ``experimental`` | f15733:c0:m1 |
def builds(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List of Builds
A paginated list of builds that have been run in
Taskcluster. Can be filtered on various git-specific
fields.
This method gives output: ``v1/build-list.json#``
This method is ``experimental`` | f15733:c0:m2 |
def badge(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Latest Build Status Badge
Checks the status of the latest build of a given branch
and returns corresponding badge svg.
This method is ``experimental`` | f15733:c0:m3 |
def repository(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Repository Info
Returns any repository metadata that is
useful within Taskcluster related services.
This method gives output: ``v1/repository.json#``
This method is ``experimental`` | f15733:c0:m4 |
def createStatus(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Post a status against a given changeset
For a given changeset (SHA) of a repository, this will attach a "commit status"
on github. These statuses are links displayed next to each revision.
The status is either OK (green check) or FAILURE (red cross),
made of a custom title and link.
This method takes input: ``v1/crea... | f15733:c0:m6 |
def createComment(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Post a comment on a given GitHub Issue or Pull Request
For a given Issue or Pull Request of a repository, this will write a new message.
This method takes input: ``v1/create-comment.json#``
This method is ``experimental`` | f15733:c0:m7 |
def workerTypeCreated(self, *args, **kwargs): | ref = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>},<EOL>{<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>},<EOL>{<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT:name>': '<S... | WorkerType Created Message
When a new `workerType` is created a message will be published to this
exchange.
This exchange outputs: ``http://schemas.taskcluster.net/aws-provisioner/v1/worker-type-message.json#``This exchange takes the following keys:
* routingKeyKind: Identifier for the routing-key kind. This is alw... | f15734:c0:m0 |
def workerTypeUpdated(self, *args, **kwargs): | ref = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>},<EOL>{<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>},<EOL>{<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT:name>': '<S... | WorkerType Updated Message
When a `workerType` is updated a message will be published to this
exchange.
This exchange outputs: ``http://schemas.taskcluster.net/aws-provisioner/v1/worker-type-message.json#``This exchange takes the following keys:
* routingKeyKind: Identifier for the routing-key kind. This is always ... | f15734:c0:m1 |
def workerTypeRemoved(self, *args, **kwargs): | ref = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>},<EOL>{<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>},<EOL>{<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT:name>': '<S... | WorkerType Removed Message
When a `workerType` is removed a message will be published to this
exchange.
This exchange outputs: ``http://schemas.taskcluster.net/aws-provisioner/v1/worker-type-message.json#``This exchange takes the following keys:
* routingKeyKind: Identifier for the routing-key kind. This is always ... | f15734:c0:m2 |
def ping(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Ping Server
Respond without doing anything.
This endpoint is used to check that the service is up.
This method is ``stable`` | f15735:c0:m0 |
def findTask(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Find Indexed Task
Find a task by index path, returning the highest-rank task with that path. If no
task exists for the given path, this API end-point will respond with a 404 status.
This method gives output: ``v1/indexed-task-response.json#``
This method is ``stable`` | f15735:c0:m1 |
def listNamespaces(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List Namespaces
List the namespaces immediately under a given namespace.
This endpoint
lists up to 1000 namespaces. If more namespaces are present, a
`continuationToken` will be returned, which can be given in the next
request. For the initial request, the payload should be an empty JSON
object.
This method gives ou... | f15735:c0:m2 |
def listTasks(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List Tasks
List the tasks immediately under a given namespace.
This endpoint
lists up to 1000 tasks. If more tasks are present, a
`continuationToken` will be returned, which can be given in the next
request. For the initial request, the payload should be an empty JSON
object.
**Remark**, this end-point is designed f... | f15735:c0:m3 |
def insertTask(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Insert Task into Index
Insert a task into the index. If the new rank is less than the existing rank
at the given index path, the task is not indexed but the response is still 200 OK.
Please see the introduction above for information
about indexing successfully completed tasks automatically using custom routes.
This... | f15735:c0:m4 |
def findArtifactFromTask(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Artifact From Indexed Task
Find a task by index path and redirect to the artifact on the most recent
run with the given `name`.
Note that multiple calls to this endpoint may return artifacts from differen tasks
if a new task is inserted into the index between calls. Avoid using this method as
a stable link to mul... | f15735:c0:m5 |
def createSession(*args, **kwargs): | return requests.Session(*args, **kwargs)<EOL> | Create a new requests session. This passes through all positional and
keyword arguments to the requests.Session() constructor | f15737:m0 |
def createTemporaryCredentials(clientId, accessToken, start, expiry, scopes, name=None): | for scope in scopes:<EOL><INDENT>if not isinstance(scope, six.string_types):<EOL><INDENT>raise exceptions.TaskclusterFailure('<STR_LIT>')<EOL><DEDENT><DEDENT>if expiry - start > datetime.timedelta(days=<NUM_LIT>):<EOL><INDENT>raise exceptions.TaskclusterFailure('<STR_LIT>')<EOL><DEDENT>cert = dict(<EOL>version=<NUM_LIT... | Create a set of temporary credentials
Callers should not apply any clock skew; clock drift is accounted for by
auth service.
clientId: the issuing clientId
accessToken: the issuer's accessToken
start: start time of credentials (datetime.datetime)
expiry: expiration time of credentials, (dateti... | f15737:m2 |
def _createSession(self): | return createSession()<EOL> | Create a requests session.
Helper method which can be overridden by child classes. | f15737:c0:m1 |
def makeHawkExt(self): | o = self.options<EOL>c = o.get('<STR_LIT>', {})<EOL>if c.get('<STR_LIT>') and c.get('<STR_LIT>'):<EOL><INDENT>ext = {}<EOL>cert = c.get('<STR_LIT>')<EOL>if cert:<EOL><INDENT>if six.PY3 and isinstance(cert, six.binary_type):<EOL><INDENT>cert = cert.decode()<EOL><DEDENT>if isinstance(cert, six.string_types):<EOL><INDENT>... | Make an 'ext' for Hawk authentication | f15737:c0:m2 |
def buildSignedUrl(self, methodName, *args, **kwargs): | if '<STR_LIT>' in kwargs:<EOL><INDENT>expiration = kwargs['<STR_LIT>']<EOL>del kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>expiration = self.options['<STR_LIT>']<EOL><DEDENT>expiration = int(time.time() + expiration) <EOL>requestUrl = self.buildUrl(methodName, *args, **kwargs)<EOL>if not self._hasCredentials():<... | Build a signed URL. This URL contains the credentials needed to access
a resource. | f15737:c0:m5 |
def _constructUrl(self, route): | return liburls.api(<EOL>self.options['<STR_LIT>'],<EOL>self.serviceName,<EOL>self.apiVersion,<EOL>route.rstrip('<STR_LIT:/>'))<EOL> | Construct a URL for the given route on this service, based on the
rootUrl | f15737:c0:m6 |
def _makeApiCall(self, entry, *args, **kwargs): | x = self._processArgs(entry, *args, **kwargs)<EOL>routeParams, payload, query, paginationHandler, paginationLimit = x<EOL>route = self._subArgsInRoute(entry, routeParams)<EOL>if paginationLimit and '<STR_LIT>' in entry.get('<STR_LIT>', []):<EOL><INDENT>query['<STR_LIT>'] = paginationLimit<EOL><DEDENT>if query:<EOL><IND... | This function is used to dispatch calls to other functions
for a given API Reference entry | f15737:c0:m7 |
def _processArgs(self, entry, *_args, **_kwargs): | <EOL>args = list(_args)<EOL>kwargs = copy.deepcopy(_kwargs)<EOL>reqArgs = entry['<STR_LIT:args>']<EOL>routeParams = {}<EOL>query = {}<EOL>payload = None<EOL>kwApiArgs = {}<EOL>paginationHandler = None<EOL>paginationLimit = None<EOL>if len(kwargs) == <NUM_LIT:0>:<EOL><INDENT>if '<STR_LIT:input>' in entry and len(args) =... | Given an entry, positional and keyword arguments, figure out what
the query-string options, payload and api arguments are. | f15737:c0:m8 |
def _subArgsInRoute(self, entry, args): | route = entry['<STR_LIT>']<EOL>for arg, val in six.iteritems(args):<EOL><INDENT>toReplace = "<STR_LIT>" % arg<EOL>if toReplace not in route:<EOL><INDENT>raise exceptions.TaskclusterFailure(<EOL>'<STR_LIT>' % (arg, entry['<STR_LIT:name>']))<EOL><DEDENT>val = urllib.parse.quote(str(val).encode("<STR_LIT:utf-8>"), '<STR_L... | Given a route like "/task/<taskId>/artifacts" and a mapping like
{"taskId": "12345"}, return a string like "/task/12345/artifacts" | f15737:c0:m9 |
def _hasCredentials(self): | cred = self.options.get('<STR_LIT>')<EOL>return (<EOL>cred and<EOL>'<STR_LIT>' in cred and<EOL>'<STR_LIT>' in cred and<EOL>cred['<STR_LIT>'] and<EOL>cred['<STR_LIT>']<EOL>)<EOL> | Return True, if credentials is given | f15737:c0:m10 |
def _makeHttpRequest(self, method, route, payload): | url = self._constructUrl(route)<EOL>log.debug('<STR_LIT>', url)<EOL>hawkExt = self.makeHawkExt()<EOL>if payload is not None:<EOL><INDENT>payload = utils.dumpJson(payload)<EOL><DEDENT>retry = -<NUM_LIT:1> <EOL>retries = self.options['<STR_LIT>']<EOL>while retry < retries:<EOL><INDENT>retry += <NUM_LIT:1><EOL>if retry >... | Make an HTTP Request for the API endpoint. This method wraps
the logic about doing failure retry and passes off the actual work
of doing an HTTP request to another method. | f15737:c0:m11 |
def ping(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Ping Server
Respond without doing anything.
This endpoint is used to check that the service is up.
This method is ``stable`` | f15738:c0:m0 |
def listClients(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List Clients
Get a list of all clients. With `prefix`, only clients for which
it is a prefix of the clientId are returned.
By default this end-point will try to return up to 1000 clients in one
request. But it **may return less, even none**.
It may also return a `continuationToken` even though there are no more
resu... | f15738:c0:m1 |
def client(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Client
Get information about a single client.
This method gives output: ``v1/get-client-response.json#``
This method is ``stable`` | f15738:c0:m2 |
def createClient(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Create Client
Create a new client and get the `accessToken` for this client.
You should store the `accessToken` from this API call as there is no
other way to retrieve it.
If you loose the `accessToken` you can call `resetAccessToken` to reset
it, and a new `accessToken` will be returned, but you cannot retrieve the
... | f15738:c0:m3 |
def resetAccessToken(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Reset `accessToken`
Reset a clients `accessToken`, this will revoke the existing
`accessToken`, generate a new `accessToken` and return it from this
call.
There is no way to retrieve an existing `accessToken`, so if you loose it
you must reset the accessToken to acquire it again.
This method gives output: ``v1/creat... | f15738:c0:m4 |
def updateClient(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Update Client
Update an exisiting client. The `clientId` and `accessToken` cannot be
updated, but `scopes` can be modified. The caller's scopes must
satisfy all scopes being added to the client in the update operation.
If no scopes are given in the request, the client's scopes remain
unchanged
This method takes inpu... | f15738:c0:m5 |
def enableClient(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Enable Client
Enable a client that was disabled with `disableClient`. If the client
is already enabled, this does nothing.
This is typically used by identity providers to re-enable clients that
had been disabled when the corresponding identity's scopes changed.
This method gives output: ``v1/get-client-response.jso... | f15738:c0:m6 |
def disableClient(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Disable Client
Disable a client. If the client is already disabled, this does nothing.
This is typically used by identity providers to disable clients when the
corresponding identity's scopes no longer satisfy the client's scopes.
This method gives output: ``v1/get-client-response.json#``
This method is ``stable`` | f15738:c0:m7 |
def deleteClient(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Delete Client
Delete a client, please note that any roles related to this client must
be deleted independently.
This method is ``stable`` | f15738:c0:m8 |
def listRoles(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List Roles
Get a list of all roles, each role object also includes the list of
scopes it expands to.
This method gives output: ``v1/list-roles-response.json#``
This method is ``stable`` | f15738:c0:m9 |
def listRoleIds(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List Role IDs
If no limit is given, the roleIds of all roles are returned. Since this
list may become long, callers can use the `limit` and `continuationToken`
query arguments to page through the responses.
This method gives output: ``v1/list-role-ids-response.json#``
This method is ``stable`` | f15738:c0:m10 |
def listRoles2(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List Roles
If no limit is given, all roles are returned. Since this
list may become long, callers can use the `limit` and `continuationToken`
query arguments to page through the responses.
This method gives output: ``v1/list-roles2-response.json#``
This method is ``stable`` | f15738:c0:m11 |
def role(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Role
Get information about a single role, including the set of scopes that the
role expands to.
This method gives output: ``v1/get-role-response.json#``
This method is ``stable`` | f15738:c0:m12 |
def createRole(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Create Role
Create a new role.
The caller's scopes must satisfy the new role's scopes.
If there already exists a role with the same `roleId` this operation
will fail. Use `updateRole` to modify an existing role.
Creation of a role that will generate an infinite expansion will result
in an error response.
This meth... | f15738:c0:m13 |
def updateRole(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Update Role
Update an existing role.
The caller's scopes must satisfy all of the new scopes being added, but
need not satisfy all of the role's existing scopes.
An update of a role that will generate an infinite expansion will result
in an error response.
This method takes input: ``v1/create-role-request.json#``
T... | f15738:c0:m14 |
def deleteRole(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Delete Role
Delete a role. This operation will succeed regardless of whether or not
the role exists.
This method is ``stable`` | f15738:c0:m15 |
def expandScopesGet(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Expand Scopes
Return an expanded copy of the given scopeset, with scopes implied by any
roles included.
This call uses the GET method with an HTTP body. It remains only for
backward compatibility.
This method takes input: ``v1/scopeset.json#``
This method gives output: ``v1/scopeset.json#``
This method is ``depre... | f15738:c0:m16 |
def expandScopes(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Expand Scopes
Return an expanded copy of the given scopeset, with scopes implied by any
roles included.
This method takes input: ``v1/scopeset.json#``
This method gives output: ``v1/scopeset.json#``
This method is ``stable`` | f15738:c0:m17 |
def currentScopes(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Current Scopes
Return the expanded scopes available in the request, taking into account all sources
of scopes and scope restrictions (temporary credentials, assumeScopes, client scopes,
and roles).
This method gives output: ``v1/scopeset.json#``
This method is ``stable`` | f15738:c0:m18 |
def awsS3Credentials(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Temporary Read/Write Credentials S3
Get temporary AWS credentials for `read-write` or `read-only` access to
a given `bucket` and `prefix` within that bucket.
The `level` parameter can be `read-write` or `read-only` and determines
which type of credentials are returned. Please note that the `level`
parameter is req... | f15738:c0:m19 |
def azureAccounts(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List Accounts Managed by Auth
Retrieve a list of all Azure accounts managed by Taskcluster Auth.
This method gives output: ``v1/azure-account-list-response.json#``
This method is ``stable`` | f15738:c0:m20 |
def azureTables(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List Tables in an Account Managed by Auth
Retrieve a list of all tables in an account.
This method gives output: ``v1/azure-table-list-response.json#``
This method is ``stable`` | f15738:c0:m21 |
def azureTableSAS(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Shared-Access-Signature for Azure Table
Get a shared access signature (SAS) string for use with a specific Azure
Table Storage table.
The `level` parameter can be `read-write` or `read-only` and determines
which type of credentials are returned. If level is read-write, it will create the
table if it doesn't alre... | f15738:c0:m22 |
def azureContainers(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List containers in an Account Managed by Auth
Retrieve a list of all containers in an account.
This method gives output: ``v1/azure-container-list-response.json#``
This method is ``stable`` | f15738:c0:m23 |
def azureContainerSAS(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Shared-Access-Signature for Azure Container
Get a shared access signature (SAS) string for use with a specific Azure
Blob Storage container.
The `level` parameter can be `read-write` or `read-only` and determines
which type of credentials are returned. If level is read-write, it will create the
container if it d... | f15738:c0:m24 |
def sentryDSN(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get DSN for Sentry Project
Get temporary DSN (access credentials) for a sentry project.
The credentials returned can be used with any Sentry client for up to
24 hours, after which the credentials will be automatically disabled.
If the project doesn't exist it will be created, and assigned to the
initial team configur... | f15738:c0:m25 |
def statsumToken(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Token for Statsum Project
Get temporary `token` and `baseUrl` for sending metrics to statsum.
The token is valid for 24 hours, clients should refresh after expiration.
This method gives output: ``v1/statsum-token-response.json#``
This method is ``stable`` | f15738:c0:m26 |
def websocktunnelToken(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a client token for the Websocktunnel service
Get a temporary token suitable for use connecting to a
[websocktunnel](https://github.com/taskcluster/websocktunnel) server.
The resulting token will only be accepted by servers with a matching audience
value. Reaching such a server is the callers responsibility. In ... | f15738:c0:m27 |
def authenticateHawk(self, *args, **kwargs): | return self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Authenticate Hawk Request
Validate the request signature given on input and return list of scopes
that the authenticating client has.
This method is used by other services that wish rely on Taskcluster
credentials for authentication. This way we can use Hawk without having
the secret credentials leave this service.
... | f15738:c0:m28 |
async def ping(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Ping Server
Respond without doing anything.
This endpoint is used to check that the service is up.
This method is ``stable`` | f15739:c0:m0 |
async def task(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Task Definition
This end-point will return the task-definition. Notice that the task
definition may have been modified by queue, if an optional property is
not specified the queue may provide a default value.
This method gives output: ``v1/task.json#``
This method is ``stable`` | f15739:c0:m1 |
async def status(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT:status>"], *args, **kwargs)<EOL> | Get task status
Get task status structure from `taskId`
This method gives output: ``v1/task-status-response.json#``
This method is ``stable`` | f15739:c0:m2 |
async def listTaskGroup(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List Task Group
List tasks sharing the same `taskGroupId`.
As a task-group may contain an unbounded number of tasks, this end-point
may return a `continuationToken`. To continue listing tasks you must call
the `listTaskGroup` again with the `continuationToken` as the
query-string option `continuationToken`.
By defau... | f15739:c0:m3 |
async def listDependentTasks(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | List Dependent Tasks
List tasks that depend on the given `taskId`.
As many tasks from different task-groups may dependent on a single tasks,
this end-point may return a `continuationToken`. To continue listing
tasks you must call `listDependentTasks` again with the
`continuationToken` as the query-string option `cont... | f15739:c0:m4 |
async def createTask(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Create New Task
Create a new task, this is an **idempotent** operation, so repeat it if
you get an internal server error or network connection is dropped.
**Task `deadline`**: the deadline property can be no more than 5 days
into the future. This is to limit the amount of pending tasks not being
taken care of. Ideall... | f15739:c0:m5 |
async def defineTask(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Define Task
**Deprecated**, this is the same as `createTask` with a **self-dependency**.
This is only present for legacy.
This method takes input: ``v1/create-task-request.json#``
This method gives output: ``v1/task-status-response.json#``
This method is ``deprecated`` | f15739:c0:m6 |
async def scheduleTask(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Schedule Defined Task
scheduleTask will schedule a task to be executed, even if it has
unresolved dependencies. A task would otherwise only be scheduled if
its dependencies were resolved.
This is useful if you have defined a task that depends on itself or on
some other task that has not been resolved, but you wish th... | f15739:c0:m7 |
async def rerunTask(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Rerun a Resolved Task
This method _reruns_ a previously resolved task, even if it was
_completed_. This is useful if your task completes unsuccessfully, and
you just want to run it from scratch again. This will also reset the
number of `retries` allowed.
This method is deprecated in favour of creating a new task with... | f15739:c0:m8 |
async def cancelTask(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Cancel Task
This method will cancel a task that is either `unscheduled`, `pending` or
`running`. It will resolve the current run as `exception` with
`reasonResolved` set to `canceled`. If the task isn't scheduled yet, ie.
it doesn't have any runs, an initial run will be added and resolved as
described above. Hence, af... | f15739:c0:m9 |
async def claimWork(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Claim Work
Claim pending task(s) for the given `provisionerId`/`workerType` queue.
If any work is available (even if fewer than the requested number of
tasks, this will return immediately. Otherwise, it will block for tens of
seconds waiting for work. If no work appears, it will return an emtpy
list of tasks. Calle... | f15739:c0:m10 |
async def claimTask(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Claim Task
claim a task - never documented
This method takes input: ``v1/task-claim-request.json#``
This method gives output: ``v1/task-claim-response.json#``
This method is ``deprecated`` | f15739:c0:m11 |
async def reclaimTask(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Reclaim task
Refresh the claim for a specific `runId` for given `taskId`. This updates
the `takenUntil` property and returns a new set of temporary credentials
for performing requests on behalf of the task. These credentials should
be used in-place of the credentials returned by `claimWork`.
The `reclaimTask` request... | f15739:c0:m12 |
async def reportCompleted(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Report Run Completed
Report a task completed, resolving the run as `completed`.
This method gives output: ``v1/task-status-response.json#``
This method is ``stable`` | f15739:c0:m13 |
async def reportFailed(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Report Run Failed
Report a run failed, resolving the run as `failed`. Use this to resolve
a run that failed because the task specific code behaved unexpectedly.
For example the task exited non-zero, or didn't produce expected output.
Do not use this if the task couldn't be run because if malformed
payload, or other u... | f15739:c0:m14 |
async def reportException(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Report Task Exception
Resolve a run as _exception_. Generally, you will want to report tasks as
failed instead of exception. You should `reportException` if,
* The `task.payload` is invalid,
* Non-existent resources are referenced,
* Declared actions cannot be executed due to unavailable resources,
* The work... | f15739:c0:m15 |
async def createArtifact(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Create Artifact
This API end-point creates an artifact for a specific run of a task. This
should **only** be used by a worker currently operating on this task, or
from a process running within the task (ie. on the worker).
All artifacts must specify when they `expires`, the queue will
automatically take care of delet... | f15739:c0:m16 |
async def completeArtifact(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Complete Artifact
This endpoint finalises an upload done through the blob `storageType`.
The queue will ensure that the task/run is still allowing artifacts
to be uploaded. For single-part S3 blob artifacts, this endpoint
will simply ensure the artifact is present in S3. For multipart S3
artifacts, the endpoint will... | f15739:c0:m17 |
async def getArtifact(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Artifact from Run
Get artifact by `<name>` from a specific run.
**Public Artifacts**, in-order to get an artifact you need the scope
`queue:get-artifact:<name>`, where `<name>` is the name of the artifact.
But if the artifact `name` starts with `public/`, authentication and
authorization is not necessary to fetch... | f15739:c0:m18 |
async def listArtifacts(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Artifacts from Run
Returns a list of artifacts and associated meta-data for a given run.
As a task may have many artifacts paging may be necessary. If this
end-point returns a `continuationToken`, you should call the end-point
again with the `continuationToken` as the query-string option:
`continuationToken`.
By... | f15739:c0:m20 |
async def listProvisioners(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a list of all active provisioners
Get all active provisioners.
The term "provisioner" is taken broadly to mean anything with a provisionerId.
This does not necessarily mean there is an associated service performing any
provisioning activity.
The response is paged. If this end-point returns a `continuationToken`,... | f15739:c0:m22 |
async def getProvisioner(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get an active provisioner
Get an active provisioner.
The term "provisioner" is taken broadly to mean anything with a provisionerId.
This does not necessarily mean there is an associated service performing any
provisioning activity.
This method gives output: ``v1/provisioner-response.json#``
This method is ``experim... | f15739:c0:m23 |
async def declareProvisioner(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Update a provisioner
Declare a provisioner, supplying some details about it.
`declareProvisioner` allows updating one or more properties of a provisioner as long as the required scopes are
possessed. For example, a request to update the `aws-provisioner-v1`
provisioner with a body `{description: 'This provisioner is ... | f15739:c0:m24 |
async def pendingTasks(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get Number of Pending Tasks
Get an approximate number of pending tasks for the given `provisionerId`
and `workerType`.
The underlying Azure Storage Queues only promises to give us an estimate.
Furthermore, we cache the result in memory for 20 seconds. So consumers
should be no means expect this to be an accurate numb... | f15739:c0:m25 |
async def listWorkerTypes(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a list of all active worker-types
Get all active worker-types for the given provisioner.
The response is paged. If this end-point returns a `continuationToken`, you
should call the end-point again with the `continuationToken` as a query-string
option. By default this end-point will list up to 1000 worker-types in... | f15739:c0:m26 |
async def getWorkerType(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a worker-type
Get a worker-type from a provisioner.
This method gives output: ``v1/workertype-response.json#``
This method is ``experimental`` | f15739:c0:m27 |
async def declareWorkerType(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Update a worker-type
Declare a workerType, supplying some details about it.
`declareWorkerType` allows updating one or more properties of a worker-type as long as the required scopes are
possessed. For example, a request to update the `gecko-b-1-w2008` worker-type within the `aws-provisioner-v1`
provisioner with a bo... | f15739:c0:m28 |
async def listWorkers(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a list of all active workers of a workerType
Get a list of all active workers of a workerType.
`listWorkers` allows a response to be filtered by quarantined and non quarantined workers.
To filter the query, you should call the end-point with `quarantined` as a query-string option with a
true or false value.
The ... | f15739:c0:m29 |
async def getWorker(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Get a worker-type
Get a worker from a worker-type.
This method gives output: ``v1/worker-response.json#``
This method is ``experimental`` | f15739:c0:m30 |
async def quarantineWorker(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Quarantine a worker
Quarantine a worker
This method takes input: ``v1/quarantine-worker-request.json#``
This method gives output: ``v1/worker-response.json#``
This method is ``experimental`` | f15739:c0:m31 |
async def declareWorker(self, *args, **kwargs): | return await self._makeApiCall(self.funcinfo["<STR_LIT>"], *args, **kwargs)<EOL> | Declare a worker
Declare a worker, supplying some details about it.
`declareWorker` allows updating one or more properties of a worker as long as the required scopes are
possessed.
This method takes input: ``v1/update-worker-request.json#``
This method gives output: ``v1/worker-response.json#``
This method is ``ex... | f15739:c0:m32 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.