def execute_deploy_manifest_pipeline(self, pipeline_name):
deployment_name = self.TEST_APP + '-deployment'
configmap_name = self.TEST_APP + '-configmap'
bindings = self.bindings
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'type': 'manual',
'user': '******'
}],
description='Deploy manifest in ' + self.TEST_APP,
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder(
'Deployment created', retryable_for_secs=60).get_resources(
'deploy',
extra_args=[
deployment_name, '--namespace', self.TEST_NAMESPACE
]).EXPECT(
self.mp.deployment_configmap_mounted_predicate(
configmap_name)))
return st.OperationContract(self.new_post_operation(
title='Deploy manifest',
data=payload,
path='pipelines/' + self.TEST_APP + '/' + pipeline_name),
contract=builder.build())
def deploy_service(self):
"""Creates an OperationContract for deploying a service object
To verify the operation, we just check that the service was created.
"""
name = self.TEST_APP + '-service'
account = self.bindings['SPINNAKER_KUBERNETES_V2_ACCOUNT']
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'moniker': {
'app': self.TEST_APP
},
'account': account,
'source': 'text',
'type': 'deployManifest',
'user': '******',
'manifests': [self.mf.service(name)],
}],
description='Deploy manifest',
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder(
'Service created', retryable_for_secs=15).get_resources(
'service',
extra_args=[name, '--namespace', self.TEST_NAMESPACE]).EXPECT(
self.mp.service_selector_predicate('app', self.TEST_APP)))
return st.OperationContract(self.new_post_operation(
title='deploy_manifest', data=payload, path='tasks'),
contract=builder.build())
def save_daemonset_pipeline(self):
deploy_stage = self.make_deploy_stage_daemonset()
job = dict(keepWaitingPipelines='false',
application=self.TEST_APP,
name='daemonset-pipeline',
lastModifiedBy='anonymous',
limitConcurrent='true',
parallel='true',
stages=[deploy_stage])
payload = self.agent.make_json_payload_from_kwargs(**job)
expect_match = {
key: jp.EQUIVALENT(value)
for key, value in job.items()
}
expect_match['stages'] = jp.LIST_MATCHES([
jp.DICT_MATCHES({
key: jp.EQUIVALENT(value)
for key, value in deploy_stage.items()
})
])
builder = st.HttpContractBuilder(self.agent)
(builder.new_clause_builder(
'Has Pipeline', retryable_for_secs=15).get_url_path(
'applications/{app}/pipelineConfigs'.format(
app=self.TEST_APP)).contains_match(expect_match))
builder = kube.KubeContractBuilder(self.kube_observer)
return st.OperationContract(self.new_post_operation(
title='Save Daemonset',
data=payload,
path='pipelines',
status_class=st.SynchronousHttpOperationStatus),
contract=builder.build())
def delete_load_balancer(self):
"""Creates OperationContract for deleteLoadBalancer.
To verify the operation, we just check that the Kubernetes resources
created by upsert_load_balancer are no longer visible in the cluster.
"""
bindings = self.bindings
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'type': 'deleteLoadBalancer',
'cloudProvider': 'kubernetes',
'loadBalancerName': self.__lb_name,
'namespace': 'default',
'account': bindings['SPINNAKER_KUBERNETES_ACCOUNT'],
'credentials': bindings['SPINNAKER_KUBERNETES_ACCOUNT'],
'regions': ['default'],
'user': '******'
}],
description='Delete Load Balancer: {0} in {1}'.format(
self.__lb_name, bindings['SPINNAKER_KUBERNETES_ACCOUNT']),
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_observer)
(builder.new_clause_builder('Service Removed',
retryable_for_secs=15).get_resources(
'svc', no_resource_ok=True))
return st.OperationContract(self.new_post_operation(
title='delete_load_balancer', data=payload, path='tasks'),
contract=builder.build())
def execute_delete_statefulset_pipeline(self):
bindings = self.bindings
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'type': 'manual',
'user': '******'
}],
description='Delete StatefulSet in Application' + self.TEST_APP,
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_observer)
(builder.new_clause_builder(
'StatefulSet Deleted', retryable_for_secs=15).get_resources(
'statefulsets',
extra_args=[
self.TEST_APP + self.POSTFIX_STATEFUL_DAEMONSET,
'--namespace', self.TEST_NAMESPACE
]).EXPECT(
ov_factory.value_list_path_contains(
'targetSize', jp.NUM_EQ(0))).OR(
self.__not_found_observation_predicate()))
return st.OperationContract(self.new_post_operation(
title='Delete_StatefulSet',
data=payload,
path='pipelines/' + self.TEST_APP + '/statefulset-delete-pipeline',
status_class=st.SynchronousHttpOperationStatus),
contract=builder.build())
def execute_bake_deploy_manifest_pipeline(self, image):
name = self.TEST_APP + "-deployment"
bindings = self.bindings
payload = self.agent.make_json_payload_from_kwargs(
job=[{
"type": "manual",
"user": "******",
}],
description="Deploy manifest in " + self.TEST_APP,
application=self.TEST_APP,
)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder(
"Deployment deployed", retryable_for_secs=90).get_resources(
"deploy",
extra_args=[name, "--namespace", self.TEST_NAMESPACE]).EXPECT(
self.mp.deployment_image_predicate(image)))
return st.OperationContract(
self.new_post_operation(
title="Deploy manifest",
data=payload,
path="pipelines/" + self.TEST_APP + "/bake-deploy-pipeline",
),
contract=builder.build(),
)
def undo_rollout_manifest(self, image):
"""Creates OperationContract for undoRolloutManifest.
To verify the operation, we just check that the deployment has changed size
"""
bindings = self.bindings
name = self.TEST_APP + '-deployment'
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'account': bindings['SPINNAKER_KUBERNETES_V2_ACCOUNT'],
'manifestName': 'deployment ' + name,
'location': self.TEST_NAMESPACE,
'type': 'undoRolloutManifest',
'user': '******',
'numRevisionsBack': 1
}],
description='Deploy manifest',
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder(
'Deployment rolled back', retryable_for_secs=15).get_resources(
'deploy',
extra_args=[name, '--namespace', self.TEST_NAMESPACE]).EXPECT(
self.__deployment_image_predicate(image)))
return st.OperationContract(self.new_post_operation(
title='undo_rollout_manifest', data=payload, path='tasks'),
contract=builder.build())
def scale_manifest(self):
"""Creates OperationContract for scaleManifest.
To verify the operation, we just check that the deployment has changed size
"""
bindings = self.bindings
name = self.TEST_APP + '-deployment'
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'account': bindings['SPINNAKER_KUBERNETES_V2_ACCOUNT'],
'manifestName': 'deployment ' + name,
'location': self.TEST_NAMESPACE,
'type': 'scaleManifest',
'user': '******',
'replicas': 2
}],
description='Deploy manifest',
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder(
'Deployment scaled', retryable_for_secs=15).get_resources(
'deploy',
extra_args=[name, '--namespace', self.TEST_NAMESPACE]).EXPECT(
ov_factory.value_list_contains(
jp.DICT_MATCHES({
'spec':
jp.DICT_MATCHES({'replicas': jp.NUM_EQ(2)})
}))))
return st.OperationContract(self.new_post_operation(
title='scale_manifest', data=payload, path='tasks'),
contract=builder.build())
def run_find_image_pipeline(self):
path = 'pipelines/{0}/{1}'.format(self.TEST_APP, self.pipeline_id)
bindings = self.bindings
group_name = frigga.Naming.server_group(
app=self.TEST_APP,
stack=bindings['TEST_STACK'],
version='v001')
payload = self.agent.make_json_payload_from_kwargs(
type='manual',
user='******')
builder = kube.KubeContractBuilder(self.kube_observer)
(builder.new_clause_builder('Replica Set Added',
retryable_for_secs=15)
.get_resources(
'rs', extra_args=[group_name, '--namespace', self.TEST_NAMESPACE])
.contains_path_eq(
'spec/template/spec/containers/image',
self.__desired_image_id))
return st.OperationContract(
self.new_post_operation(
title='run_find_image_pipeline', data=payload, path=path),
builder.build())
def deploy_config_map(self, version):
"""Creates OperationContract for deploying a versioned configmap
To verify the operation, we just check that the deployment was created with
the correct image.
"""
bindings = self.bindings
name = self.TEST_APP + '-configmap'
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'moniker': {
'app': self.TEST_APP
},
'account': bindings['SPINNAKER_KUBERNETES_V2_ACCOUNT'],
'source': 'text',
'type': 'deployManifest',
'user': '******',
'manifests': [self.mf.config_map(name, {'version': version})],
}],
description='Deploy manifest',
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder('ConfigMap created',
retryable_for_secs=15)
.get_resources(
'configmap',
extra_args=[name + '-' + version, '--namespace', self.TEST_NAMESPACE])
.EXPECT(self.mp.config_map_key_value_predicate('version', version)))
return st.OperationContract(
self.new_post_operation(
title='deploy_manifest', data=payload, path='tasks'),
contract=builder.build())
def create_server_group(self):
"""Creates OperationContract for createServerGroup.
To verify the operation, we just check that the server group was created.
"""
bindings = self.bindings
# Spinnaker determines the group name created,
# which will be the following:
group_name = '{app}-{stack}-v000'.format(
app=self.TEST_APP, stack=bindings['TEST_STACK'])
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'application': self.TEST_APP,
'account': bindings['KUBE_CREDENTIALS'],
'strategy':'',
'targetSize': 2,
'containers': [{
'name': 'librarynginx',
'imageDescription': {
'repository': 'library/nginx',
'tag': 'stable',
'imageId': 'index.docker.io/library/nginx:stable',
'registry': 'index.docker.io'
},
'requests': {'memory':None, 'cpu':None},
'limits': {'memory':None, 'cpu':None},
'ports':[{'name':'http', 'containerPort':80,
'protocol':'TCP', 'hostPort':None, 'hostIp':None}]
}],
'stack': bindings['TEST_STACK'],
# TODO(ewiseblatt): 20160316
# We cannot create a load balancer yet, so test without one.
# 'loadBalancers': [self.__lb_name],
'type': 'createServerGroup',
'region': 'default',
'user': '******'
}],
description='Create Server Group in ' + group_name,
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_observer)
(builder.new_clause_builder('Managed Instance Group Added',
retryable_for_secs=15)
.get_resources('rc', extra_args=[group_name])
.contains_path_eq('spec/replicas', 2))
return st.OperationContract(
self.new_post_operation(
title='create_server_group', data=payload, path='tasks'),
contract=builder.build())
def deploy_deployment_with_config_map(self, versioned):
"""Creates OperationContract for deploying a configmap along with a deployment
mounting this configmap.
To verify the operation, we just check that the deployment was created with
the correct configmap mounted
"""
deployment_name = self.TEST_APP + "-deployment"
deployment = self.mf.deployment(deployment_name, "library/nginx")
configmap_name = self.TEST_APP + "-configmap"
configmap = self.mf.config_map(configmap_name, {"key": "value"})
if not versioned:
configmap["metadata"]["annotations"] = {
"strategy.spinnaker.io/versioned": "false"
}
self.mf.add_configmap_volume(deployment, configmap_name)
payload = self.agent.make_json_payload_from_kwargs(
job=[
{
"cloudProvider": "kubernetes",
"moniker": {"app": self.TEST_APP},
"account": self.bindings["SPINNAKER_KUBERNETES_V2_ACCOUNT"],
"source": "text",
"type": "deployManifest",
"user": "******",
"manifests": [deployment, configmap],
}
],
description="Deploy manifest",
application=self.TEST_APP,
)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(
builder.new_clause_builder("Deployment created", retryable_for_secs=15)
.get_resources(
"deploy",
extra_args=[deployment_name, "--namespace", self.TEST_NAMESPACE],
)
.EXPECT(self.mp.deployment_configmap_mounted_predicate(configmap_name))
)
return st.OperationContract(
self.new_post_operation(
title="deploy_manifest", data=payload, path="tasks"
),
contract=builder.build(),
)
def patch_manifest(self):
"""Creates OperationContract for patchManifest.
To verify the operation, we just check that the deployment was created.
"""
bindings = self.bindings
name = self.TEST_APP + '-deployment'
test_label = 'patchedLabel'
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'account': bindings['SPINNAKER_KUBERNETES_V2_ACCOUNT'],
'cloudProvider': 'kubernetes',
'kind': 'deployment',
'location': self.TEST_NAMESPACE,
'manifestName': 'deployment ' + name,
'type': 'patchManifest',
'user': '******',
'source': 'text',
'patchBody': {
'metadata': {
'labels': {
'testLabel': test_label,
}
}
},
'options': {
'mergeStrategy': 'strategic',
'record': True
}
}],
description='Patch manifest',
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder('Deployment patched',
retryable_for_secs=15)
.get_resources(
'deploy',
extra_args=[name, '--namespace', self.TEST_NAMESPACE])
.EXPECT(ov_factory.value_list_contains(jp.DICT_MATCHES({
'metadata': jp.DICT_MATCHES({
'labels': jp.DICT_MATCHES({
'testLabel': jp.STR_EQ(test_label)
})
})
}))))
return st.OperationContract(
self.new_post_operation(
title='patch_manifest', data=payload, path='tasks'),
contract=builder.build())
def upsert_load_balancer(self):
"""Creates OperationContract for upsertLoadBalancer.
Calls Spinnaker's upsertLoadBalancer with a configuration, then verifies
that the expected resources and configurations are visible on Kubernetes.
See the contract builder for more info on what the expectations are.
"""
bindings = self.bindings
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'availabilityZones': {
self.TEST_NAMESPACE: [self.TEST_NAMESPACE]
},
'provider': 'kubernetes',
'stack': bindings['TEST_STACK'],
'detail': self.__lb_detail,
'serviceType': 'ClusterIP',
'account': bindings['SPINNAKER_KUBERNETES_ACCOUNT'],
'namespace': self.TEST_NAMESPACE,
'ports': [{
'protocol': 'TCP',
'port': 80,
'name': 'http'
}],
'externalIps': [],
'sessionAffinity': 'None',
'clusterIp': '',
'loadBalancerIp': '',
'name': self.__lb_name,
'healthCheck': ':undefined', # deck has this leading ':'
'type': 'upsertLoadBalancer',
'securityGroups': None,
'user': '******'
}],
description='Create Load Balancer: ' + self.__lb_name,
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_observer)
(builder.new_clause_builder(
'Service Added', retryable_for_secs=15).get_resources(
'svc',
extra_args=['--namespace', self.TEST_NAMESPACE
]).contains_path_value('items/metadata/name',
self.__lb_name))
return st.OperationContract(self.new_post_operation(
title='upsert_load_balancer', data=payload, path='tasks'),
contract=builder.build())
def deploy_spel_deployment_from_gcs(self, image):
"""Creates OperationContract for deploying and substituting one image into
a Deployment object using a SpEL expression.
To verify the operation, we just check that the deployment was created with
the correct image.
"""
bindings = self.bindings
name = self.TEST_APP + "-deployment"
manifest = self.mf.deployment(name, "${image}")
manifest_artifact = self.__gcs_manifest_expected_artifact(
json.dumps(manifest), "manifest-spel.yaml"
)
payload = self.agent.make_json_payload_from_kwargs(
job=[
{
"cloudProvider": "kubernetes",
"moniker": {"app": self.TEST_APP},
"account": bindings["SPINNAKER_KUBERNETES_V2_ACCOUNT"],
"source": "artifact",
"type": "deployManifest",
"user": "******",
"image": image,
"manifestArtifactAccount": self.ARTIFACT_ACCOUNT,
"manifestArtifactId": manifest_artifact["id"],
"resolvedExpectedArtifacts": [manifest_artifact],
}
],
description="Deploy manifest",
application=self.TEST_APP,
)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(
builder.new_clause_builder("Deployment created", retryable_for_secs=15)
.get_resources(
"deploy", extra_args=[name, "--namespace", self.TEST_NAMESPACE]
)
.EXPECT(self.mp.deployment_image_predicate(image))
)
return st.OperationContract(
self.new_post_operation(
title="deploy_manifest", data=payload, path="tasks"
),
contract=builder.build(),
)
def deploy_deployment_with_config_map(self, versioned):
"""Creates OperationContract for deploying a configmap along with a deployment
mounting this configmap.
To verify the operation, we just check that the deployment was created with
the correct configmap mounted
"""
deployment_name = self.TEST_APP + '-deployment'
deployment = self.mf.deployment(deployment_name, 'library/nginx')
configmap_name = self.TEST_APP + '-configmap'
configmap = self.mf.config_map(configmap_name, {'key': 'value'})
if not versioned:
configmap['metadata']['annotations'] = {
'strategy.spinnaker.io/versioned': 'false'
}
self.mf.add_configmap_volume(deployment, configmap_name)
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'moniker': {
'app': self.TEST_APP
},
'account': self.bindings['SPINNAKER_KUBERNETES_V2_ACCOUNT'],
'source': 'text',
'type': 'deployManifest',
'user': '******',
'manifests': [deployment, configmap],
}],
description='Deploy manifest',
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder(
'Deployment created', retryable_for_secs=15).get_resources(
'deploy',
extra_args=[
deployment_name, '--namespace', self.TEST_NAMESPACE
]).EXPECT(
self.mp.deployment_configmap_mounted_predicate(
configmap_name)))
return st.OperationContract(self.new_post_operation(
title='deploy_manifest', data=payload, path='tasks'),
contract=builder.build())
def delete_kind(self, kind, version=None):
"""Creates OperationContract for deleteManifest
To verify the operation, we just check that the Kubernetes deployment
is no longer visible (or is in the process of terminating).
"""
bindings = self.bindings
name = self.TEST_APP + "-" + kind
payload = self.agent.make_json_payload_from_kwargs(
job=[{
"cloudProvider": "kubernetes",
"type": "deleteManifest",
"account": bindings["SPINNAKER_KUBERNETES_V2_ACCOUNT"],
"user": "******",
"kinds": [kind],
"location": self.TEST_NAMESPACE,
"options": {},
"labelSelectors": {
"selectors": [{
"kind": "EQUALS",
"key": "app",
"values": [self.TEST_APP]
}]
},
}],
application=self.TEST_APP,
description="Destroy Manifest",
)
if version is not None:
name = name + "-" + version
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder("Manifest Removed").get_resources(
kind,
extra_args=[name, "--namespace", self.TEST_NAMESPACE
]).EXPECT(self.mp.not_found_observation_predicate()))
return st.OperationContract(
self.new_post_operation(title="delete_kind",
data=payload,
path="tasks"),
contract=builder.build(),
)
def deploy_deployment_with_docker_artifact(self, image):
"""Creates OperationContract for deploying and substituting one image into
a Deployment object
To verify the operation, we just check that the deployment was created with
the correct image.
"""
bindings = self.bindings
name = self.TEST_APP + "-deployment"
image_name = "placeholder"
docker_artifact = self.__docker_image_artifact(image_name, image)
payload = self.agent.make_json_payload_from_kwargs(
job=[
{
"cloudProvider": "kubernetes",
"moniker": {"app": self.TEST_APP},
"account": bindings["SPINNAKER_KUBERNETES_V2_ACCOUNT"],
"source": "text",
"type": "deployManifest",
"user": "******",
"manifests": [self.mf.deployment(name, image_name)],
"artifacts": [docker_artifact],
}
],
description="Deploy manifest",
application=self.TEST_APP,
)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(
builder.new_clause_builder("Deployment created", retryable_for_secs=15)
.get_resources(
"deploy", extra_args=[name, "--namespace", self.TEST_NAMESPACE]
)
.EXPECT(self.mp.deployment_image_predicate(image))
)
return st.OperationContract(
self.new_post_operation(
title="deploy_manifest", data=payload, path="tasks"
),
contract=builder.build(),
)
def deploy_unversioned_config_map(self, value):
"""Creates OperationContract for deploying an unversioned configmap
To verify the operation, we just check that the configmap was created with
the correct 'value'.
"""
name = self.TEST_APP + "-configmap"
manifest = self.mf.config_map(name, {"value": value})
manifest["metadata"]["annotations"] = {
"strategy.spinnaker.io/versioned": "false"
}
payload = self.agent.make_json_payload_from_kwargs(
job=[
{
"cloudProvider": "kubernetes",
"moniker": {"app": self.TEST_APP},
"account": self.bindings["SPINNAKER_KUBERNETES_V2_ACCOUNT"],
"source": "text",
"type": "deployManifest",
"user": "******",
"manifests": [manifest],
}
],
description="Deploy manifest",
application=self.TEST_APP,
)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(
builder.new_clause_builder("ConfigMap created", retryable_for_secs=15)
.get_resources(
"configmap", extra_args=[name, "--namespace", self.TEST_NAMESPACE]
)
.EXPECT(self.mp.config_map_key_value_predicate("value", value))
)
return st.OperationContract(
self.new_post_operation(
title="deploy_manifest", data=payload, path="tasks"
),
contract=builder.build(),
)
def delete_kind(self, kind, version=None):
"""Creates OperationContract for deleteManifest
To verify the operation, we just check that the Kubernetes deployment
is no longer visible (or is in the process of terminating).
"""
bindings = self.bindings
name = self.TEST_APP + '-' + kind
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'type': 'deleteManifest',
'account': bindings['SPINNAKER_KUBERNETES_V2_ACCOUNT'],
'user': '******',
'kinds': [ kind ],
'location': self.TEST_NAMESPACE,
'options': { },
'labelSelectors': {
'selectors': [{
'kind': 'EQUALS',
'key': 'app',
'values': [ self.TEST_APP ]
}]
}
}],
application=self.TEST_APP,
description='Destroy Manifest')
if version is not None:
name = name + '-' + version
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder('Manifest Removed')
.get_resources(
kind,
extra_args=[name, '--namespace', self.TEST_NAMESPACE])
.EXPECT(self.mp.not_found_observation_predicate()))
return st.OperationContract(
self.new_post_operation(
title='delete_kind', data=payload, path='tasks'),
contract=builder.build())
def delete_server_group(self, version='v000'):
"""Creates OperationContract for deleteServerGroup.
To verify the operation, we just check that the Kubernetes container
is no longer visible (or is in the process of terminating).
"""
bindings = self.bindings
group_name = frigga.Naming.server_group(app=self.TEST_APP,
stack=bindings['TEST_STACK'],
version=version)
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'type': 'destroyServerGroup',
'account': bindings['SPINNAKER_KUBERNETES_ACCOUNT'],
'credentials': bindings['SPINNAKER_KUBERNETES_ACCOUNT'],
'user': '******',
'serverGroupName': group_name,
'asgName': group_name,
'regions': [self.TEST_NAMESPACE],
'namespace': self.TEST_NAMESPACE,
'region': self.TEST_NAMESPACE,
'zones': [self.TEST_NAMESPACE],
'interestingHealthProviderNames': ['KubernetesService']
}],
application=self.TEST_APP,
description='Destroy Server Group: ' + group_name)
builder = kube.KubeContractBuilder(self.kube_observer)
(builder.new_clause_builder('Replica Set Removed').get_resources(
'rs',
extra_args=[group_name, '--namespace',
self.TEST_NAMESPACE]).EXPECT(
ov_factory.value_list_path_contains(
'targetSize', jp.NUM_EQ(0))).OR(
self.__not_found_observation_predicate()))
return st.OperationContract(self.new_post_operation(
title='delete_server_group', data=payload, path='tasks'),
contract=builder.build())
def deploy_spel_deployment_from_gcs(self, image):
"""Creates OperationContract for deploying and substituting one image into
a Deployment object using a SpEL expression.
To verify the operation, we just check that the deployment was created with
the correct image.
"""
bindings = self.bindings
name = self.TEST_APP + '-deployment'
manifest = self.mf.deployment(name, '${image}')
manifest_artifact = self.__gcs_manifest_expected_artifact(json.dumps(manifest), 'manifest-spel.yaml')
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'moniker': {
'app': self.TEST_APP
},
'account': bindings['SPINNAKER_KUBERNETES_V2_ACCOUNT'],
'source': 'artifact',
'type': 'deployManifest',
'user': '******',
'image': image,
'manifestArtifactAccount': self.ARTIFACT_ACCOUNT,
'manifestArtifactId': manifest_artifact['id'],
'resolvedExpectedArtifacts': [manifest_artifact]
}],
description='Deploy manifest',
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder('Deployment created',
retryable_for_secs=15)
.get_resources(
'deploy',
extra_args=[name, '--namespace', self.TEST_NAMESPACE])
.EXPECT(self.mp.deployment_image_predicate(image)))
return st.OperationContract(
self.new_post_operation(
title='deploy_manifest', data=payload, path='tasks'),
contract=builder.build())
def create_daemonset_pipeline(self):
bindings = self.bindings
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'type': 'manual',
'user': '******'
}],
description='Create Daemonset in Application' + self.TEST_APP,
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_observer)
(builder.new_clause_builder('Daemonset Added', retryable_for_secs=15)
.get_resources(
'daemonsets', extra_args=[self.TEST_APP + self.POSTFIX_STATEFUL_DAEMONSET,
'--namespace', self.TEST_NAMESPACE])
.contains_path_value('kind', 'DaemonSet'))
return st.OperationContract(
self.new_post_operation(
title='Create_daemonset', data=payload,
path='pipelines/' + self.TEST_APP + '/daemonset-pipeline',
status_class=st.SynchronousHttpOperationStatus),
contract=builder.build())
def deploy_deployment_with_docker_artifact(self, image):
"""Creates OperationContract for deploying and substituting one image into
a Deployment object
To verify the operation, we just check that the deployment was created with
the correct image.
"""
bindings = self.bindings
name = self.TEST_APP + '-deployment'
image_name = 'placeholder'
docker_artifact = self.__docker_image_artifact(image_name, image)
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'moniker': {
'app': self.TEST_APP
},
'account': bindings['SPINNAKER_KUBERNETES_V2_ACCOUNT'],
'source': 'text',
'type': 'deployManifest',
'user': '******',
'manifests': [self.mf.deployment(name, image_name)],
'artifacts': [docker_artifact]
}],
description='Deploy manifest',
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder('Deployment created',
retryable_for_secs=15)
.get_resources(
'deploy',
extra_args=[name, '--namespace', self.TEST_NAMESPACE])
.EXPECT(self.mp.deployment_image_predicate(image)))
return st.OperationContract(
self.new_post_operation(
title='deploy_manifest', data=payload, path='tasks'),
contract=builder.build())
def execute_deploy_manifest_pipeline(self, image):
name = self.TEST_APP + '-deployment'
bindings = self.bindings
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'type': 'manual',
'user': '******'
}],
description='Deploy manifest in ' + self.TEST_APP,
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder(
'Deployment deployed', retryable_for_secs=15).get_resources(
'deploy',
extra_args=[name, '--namespace', self.TEST_NAMESPACE]).EXPECT(
self.mp.deployment_image_predicate(image)))
return st.OperationContract(self.new_post_operation(
title='Deploy manifest',
data=payload,
path='pipelines/' + self.TEST_APP + '/deploy-manifest-pipeline',
status_class=st.SynchronousHttpOperationStatus),
contract=builder.build())
def delete_server_group(self, version='v000'):
"""Creates OperationContract for deleteServerGroup.
To verify the operation, we just check that the Kubernetes container
is no longer visible (or is in the process of terminating).
"""
bindings = self.bindings
group_name = frigga.Naming.server_group(app=self.TEST_APP,
stack=bindings['TEST_STACK'],
version=version)
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider': 'kubernetes',
'type': 'destroyServerGroup',
'account': bindings['KUBE_CREDENTIALS'],
'credentials': bindings['KUBE_CREDENTIALS'],
'user': '******',
'serverGroupName': group_name,
'asgName': group_name,
'regions': ['default'],
'region': 'default',
'zones': ['default'],
'interestingHealthProviderNames': ['KubernetesService']
}],
application=self.TEST_APP,
description='Destroy Server Group: ' + group_name)
builder = kube.KubeContractBuilder(self.kube_observer)
(builder.new_clause_builder(
'Replication Controller Removed').get_resources(
'rc', extra_args=[group_name],
no_resource_ok=True).contains_path_eq('targetSize', 0))
return st.OperationContract(self.new_post_operation(
title='delete_server_group', data=payload, path='tasks'),
contract=builder.build())
def deploy_service(self):
"""Creates an OperationContract for deploying a service object
To verify the operation, we just check that the service was created.
"""
name = self.TEST_APP + "-service"
account = self.bindings["SPINNAKER_KUBERNETES_V2_ACCOUNT"]
payload = self.agent.make_json_payload_from_kwargs(
job=[{
"cloudProvider": "kubernetes",
"moniker": {
"app": self.TEST_APP
},
"account": account,
"source": "text",
"type": "deployManifest",
"user": "******",
"manifests": [self.mf.service(name)],
}],
description="Deploy manifest",
application=self.TEST_APP,
)
builder = kube.KubeContractBuilder(self.kube_v2_observer)
(builder.new_clause_builder(
"Service created", retryable_for_secs=15).get_resources(
"service",
extra_args=[name, "--namespace", self.TEST_NAMESPACE]).EXPECT(
self.mp.service_selector_predicate("app", self.TEST_APP)))
return st.OperationContract(
self.new_post_operation(title="deploy_manifest",
data=payload,
path="tasks"),
contract=builder.build(),
)
def create_server_group(self):
"""Creates OperationContract for createServerGroup.
To verify the operation, we just check that the server group was created.
"""
bindings = self.bindings
# Spinnaker determines the group name created,
# which will be the following:
group_name = frigga.Naming.server_group(app=self.TEST_APP,
stack=bindings['TEST_STACK'],
version='v000')
payload = self.agent.make_json_payload_from_kwargs(
job=[{
'cloudProvider':
'kubernetes',
'application':
self.TEST_APP,
'account':
bindings['SPINNAKER_KUBERNETES_ACCOUNT'],
'strategy':
'',
'targetSize':
1,
'containers': [{
'name':
'validated',
'imageDescription': {
'repository': self.__image_repository,
'tag': self.__desired_image_tag,
'imageId': self.__desired_image_id,
'registry': self.__image_registry
},
'requests': {
'memory': None,
'cpu': None
},
'limits': {
'memory': None,
'cpu': None
},
'ports': [{
'name': 'http',
'containerPort': 80,
'protocol': 'TCP',
'hostPort': None,
'hostIp': None
}]
},
{
'name':
'broken',
'imageDescription': {
'repository': self.__image_repository,
'tag': self.__undesired_image_tag,
'imageId': self.__undesired_image_id,
'registry': self.__image_registry
},
'requests': {
'memory': None,
'cpu': None
},
'limits': {
'memory': None,
'cpu': None
},
'ports': [{
'name': 'http',
'containerPort': 80,
'protocol': 'TCP',
'hostPort': None,
'hostIp': None
}]
}],
'stack':
bindings['TEST_STACK'],
'loadBalancers': [self.__lb_name],
'type':
'createServerGroup',
'region':
'default',
'user':
'******'
}],
description='Create Server Group in ' + group_name,
application=self.TEST_APP)
builder = kube.KubeContractBuilder(self.kube_observer)
(builder.new_clause_builder(
'Replica Set Added', retryable_for_secs=15).get_resources(
'rs',
extra_args=[group_name]).contains_path_eq('spec/replicas', 1))
return st.OperationContract(self.new_post_operation(
title='create_server_group', data=payload, path='tasks'),
contract=builder.build())
