Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def wait_for_stack_status(stack_id, target_status):
"""
Poll the status of a CloudFormation stack.
:param unicode stack_id: The AWS cloudformation stack ID.
:param unicode target_status: The desired stack status.
:returns: A ``Deferred`` which fires when the stack has ``target_status``.
"""
Message.log(
function='wait_for_stack_status',
stack_id=stack_id,
target_status=target_status,
)
def predicate():
stack_report = get_stack_report(stack_id)
current_status = stack_report['StackStatus']
if current_status == target_status:
return stack_report
return loop_until(reactor, predicate, repeat(10, 60))
def handlePLAINTEXTServer(self, header):
"""
Parse a complete HTTP-like Foolscap negotiation request and begin proxying
to a destination selected based on the extract TubID.
"""
# the client sends us a GET message
lines = header.split("\r\n")
if not lines[0].startswith("GET "):
raise BananaError("not right")
command, url, version = lines[0].split()
if not url.startswith("/id/"):
# probably a web browser
raise BananaError("not right")
targetTubID = url[4:]
Message.log(event_type=u"handlePLAINTEXTServer", tub_id=targetTubID)
if targetTubID == "":
# they're asking for an old UnauthenticatedTub. Refuse.
raise NegotiationError("secure Tubs require encryption")
if isSubstring("Upgrade: TLS/1.0\r\n", header):
wantEncrypted = True
else:
wantEncrypted = False
Message.log(event_type=u"handlePLAINTEXTServer", want_encrypted=wantEncrypted)
self._handleTubRequest(header, targetTubID)
def start_containers(nodes):
Message.log(
message_type='flocker.benchmark.container_setup:start',
containers_per_node=per_node,
total_nodes=len(nodes)
)
total = per_node * len(nodes)
def log_progress():
Message.log(
message_type='flocker.benchmark.container_setup:progress',
container_count=self.container_count,
error_count=self.error_count,
total_containers=total
)
loop = LoopingCall(log_progress)
loop.start(10, now=False)
def instance_error(failure):
Message.log(
message_type="flocker:provision:aws:async_get_node:failed"
)
instance.terminate()
write_failure(failure)
return failure
def _converge_replicasets(actual, config, subscriptions, k8s, aws):
# We don't ever have to create a ReplicaSet. We'll just delete the ones
# we don't need anymore.
deletes = []
for replicaset in actual.replicasets:
sid = replicaset.metadata.annotations[u"subscription"]
if sid not in actual.subscriptions:
Message.log(condition=u"undesired", subscription=sid)
deletes.append(replicaset.metadata)
def delete(metadata):
return k8s.delete(k8s.k8s.model.v1beta1.ReplicaSet(metadata=metadata))
return list(partial(delete, metadata) for metadata in deletes)
def check_state(node):
if node is not None:
if node.state in target_states:
Message.log(
message_type=(
u"flocker:provision:libcloud:node_in_state"
),
name=node.name,
id=node.id,
state=node.state,
)
return True
return False
}
success = False
headers_required = opts['headers_required']
if not isinstance(headers_required, dict):
raise ParserException('headers_required must be a list of headers')
for header in headers_required:
if header in response.headers:
if headers_required[header] == '.':
continue
if str(headers_required[header]) != response.headers[header]:
Message.log(
level='status',
message="Header '%s: %s' different from response header '%s: %s'" % (header, headers_required[header], header, response.headers[header]))
success = True
else:
success = True
return success, scope
def got_nodes(nodes):
for node in nodes:
if node.uuid == target_node.uuid:
Message.log(
message_type=(
u"flocker:provision:libcloud:refresh_node"
),
name=node.name,
id=node.id,
state=node.state,
public_ips=node.public_ips,
private_ips=node.private_ips,
)
return node
return None