def update_flow_ver(process_group, target_version=None):
"""
Changes a versioned flow to the specified version, or the latest version
Args:
process_group (ProcessGroupEntity): ProcessGroupEntity under version
control to change
target_version (Optional [None, Int]): Either None to move to the
latest available version, or Int of the version number to move to
Returns:
(bool): True if successful, False if not
"""
def _running_update_flow_version():
"""
Tests for completion of the operation
Returns:
(bool) Boolean of operation success
"""
status = nipyapi.nifi.VersionsApi().get_update_request(
u_init.request.request_id)
if not status.request.complete:
return False
if status.request.failure_reason is None:
return True
raise ValueError("Flow Version Update did not complete successfully. "
"Error text {0}".format(
status.request.failure_reason))
with nipyapi.utils.rest_exceptions():
vci = get_version_info(process_group)
assert isinstance(vci, nipyapi.nifi.VersionControlInformationEntity)
flow_vers = list_flow_versions(
vci.version_control_information.bucket_id,
vci.version_control_information.flow_id)
if target_version is None:
# the first version is always the latest available
ver = flow_vers[0].version
else:
# otherwise the version must be an int
if not isinstance(target_version, int):
raise ValueError("target_version must be a positive Integer to"
" pick a specific available version, or None"
" for the latest version to be fetched")
ver = target_version
u_init = nipyapi.nifi.VersionsApi().initiate_version_control_update(
id=process_group.id,
body=nipyapi.nifi.VersionControlInformationEntity(
process_group_revision=vci.process_group_revision,
version_control_information=VciDTO(
bucket_id=vci.version_control_information.bucket_id,
flow_id=vci.version_control_information.flow_id,
group_id=vci.version_control_information.group_id,
registry_id=vci.version_control_information.registry_id,
version=ver)))
nipyapi.utils.wait_to_complete(_running_update_flow_version)
return nipyapi.nifi.VersionsApi().get_update_request(
u_init.request.request_id)
def deploy_flow_version(parent_id, location, bucket_id, flow_id, reg_client_id,
version=None):
"""
Deploys a versioned flow as a new process group inside the given parent
process group. If version is not provided, the latest version will be
deployed.
Args:
parent_id (str): The ID of the parent Process Group to create the
new process group in.
location (tuple[x, y]): the x,y coordinates to place the new Process
Group under the parent
bucket_id (str): ID of the bucket containing the versioned flow to
deploy.
flow_id (str): ID of the versioned flow to deploy.
version (Optional [int,str]): version to deploy, if not provided latest
version will be deployed.
Returns:
(ProcessGroupEntity) of the newly deployed Process Group
"""
assert isinstance(location, tuple)
try:
# Being pedantic about checking this as API failure errors are terse
# Check flow details are valid
target_flow = get_flow_version(
bucket_id=bucket_id,
flow_id=flow_id,
version=str(version)
)
# check reg client is valid
target_reg_client = get_registry_client(reg_client_id, 'id')
# Issue deploy statement
return nipyapi.nifi.ProcessGroupsApi().create_process_group(
id=parent_id,
body=nipyapi.nifi.ProcessGroupEntity(
revision=nipyapi.nifi.RevisionDTO(
version=0
),
component=nipyapi.nifi.ProcessGroupDTO(
position=nipyapi.nifi.PositionDTO(
x=float(location[0]),
y=float(location[1])
),
version_control_information=VciDTO(
bucket_id=target_flow.bucket.identifier,
flow_id=target_flow.flow.identifier,
registry_id=target_reg_client.id,
version=target_flow.snapshot_metadata.version
)
)
)
)
except nipyapi.nifi.rest.ApiException as e:
raise ValueError(e.body)
def deploy_flow_version(parent_id, location, bucket_id, flow_id, reg_client_id,
version=None):
"""
Deploys a versioned flow as a new process group inside the given parent
process group. If version is not provided, the latest version will be
deployed.
Args:
parent_id (str): The ID of the parent Process Group to create the
new process group in.
location (tuple[x, y]): the x,y coordinates to place the new Process
Group under the parent
bucket_id (str): ID of the bucket containing the versioned flow to
deploy.
reg_client_id (str): ID of the registry client connection to use.
flow_id (str): ID of the versioned flow to deploy.
version (Optional [int,str]): version to deploy, if not provided latest
version will be deployed.
Returns:
(ProcessGroupEntity) of the newly deployed Process Group
"""
assert isinstance(location, tuple)
# check reg client is valid
target_reg_client = get_registry_client(reg_client_id, 'id')
# Being pedantic about checking this as API failure errors are terse
# Using NiFi here to keep all calls within the same API client
flow_versions = list_flow_versions(
bucket_id=bucket_id,
flow_id=flow_id,
registry_id=reg_client_id,
service='nifi'
)
if not flow_versions:
raise ValueError("Could not find Flows matching Bucket ID [{0}] and"
"Flow ID [{1}] on Registry Client [{2}]"
.format(bucket_id, flow_id, reg_client_id))
if version is None:
target_flow = flow_versions.versioned_flow_snapshot_metadata_set
else:
target_flow = [x for x
in flow_versions.versioned_flow_snapshot_metadata_set
if x.versioned_flow_snapshot_metadata.version == version
]
if not target_flow:
raise ValueError(
"Could not find Version [{0}] for Flow [{1}] in Bucket [{2}] on "
"Registry Client [{3}]"
.format(str(version), flow_id, bucket_id, reg_client_id)
)
target_flow = target_flow[0].versioned_flow_snapshot_metadata
# Issue deploy statement
with nipyapi.utils.rest_exceptions():
return nipyapi.nifi.ProcessGroupsApi().create_process_group(
id=parent_id,
body=nipyapi.nifi.ProcessGroupEntity(
revision=nipyapi.nifi.RevisionDTO(
version=0
),
component=nipyapi.nifi.ProcessGroupDTO(
position=nipyapi.nifi.PositionDTO(
x=float(location[0]),
y=float(location[1])
),
version_control_information=VciDTO(
bucket_id=target_flow.bucket_identifier,
flow_id=target_flow.flow_identifier,
registry_id=target_reg_client.id,
version=target_flow.version
)
)
)
)