Ready code for 6.2 release and misc bug fixes (#97)

Update to 6.2 Service Fabric runtime
Rename and change value of application upgrade parameter application-name to application-id

src/README.rst

@@ -16,7 +16,7 @@ To get started, after installation run the following:
 Change Log
 ==========
 
-Unreleased
+5.0.0
 -----
 - Add commands to get and set chaos schedule (#70)
 - Add commands to get chaos and get events for chaos (#70)
@@ -27,7 +27,9 @@ Unreleased
 - Add tests to verify correctness of help text (#71)
 - Add scaling policy parameter to the command for service create and the command for service update (#76)
 - Add new group called container with commands: invoke-api (invoke raw container REST API) and logs (get container logs) (#82)
-- Add support for passing json values to arguments as .txt files (#84)
+- Add support for passing json values to arguments as .txt files. Input starting with '@' are considered paths (#84)
+- Update to 6.2 Service Fabric runtime (#97)
+- Rename and change value of application upgrade parameter application-name to application-id (#97)
 
 4.0.0
 -----

src/setup.py

@@ -47,7 +47,7 @@ def read(fname):
         'msrest>=0.4.26',
         'msrestazure',
         'requests',
-        'azure-servicefabric==6.1.2.9',
+        'azure-servicefabric==6.2.0.0',
         'jsonpickle',
         'adal',
         'future'

src/sfctl/custom_app.py

@@ -166,7 +166,7 @@ def parse_app_params(formatted_params):
 
     res = []
     for k in formatted_params:
-        param = ApplicationParameter(k, formatted_params[k])
+        param = ApplicationParameter(key=k, value=formatted_params[k])
         res.append(param)
 
     return res
@@ -181,18 +181,23 @@ def parse_app_metrics(formatted_metrics):
         return None
 
     res = []
+
     for metric in formatted_metrics:
         metric_name = metric.get('name', None)
+
         if not metric_name:
             raise CLIError('Could not find required application metric name')
 
-        metric_max_cap = metric.get('maximum_capacity', None)
-        metric_reserve_cap = metric.get('reservation_capacity', None)
-        metric_total_cap = metric.get('total_application_capacity', None)
-        metric_desc = ApplicationMetricDescription(metric_name, metric_max_cap,
-                                                   metric_reserve_cap,
-                                                   metric_total_cap)
-        res.append(metric_desc)
+        maximum_capacity = metric.get('maximum_capacity', None)
+        reservation_capacity = metric.get('reservation_capacity', None)
+        total_application_capacity = metric.get('total_application_capacity', None)
+
+        res.append(ApplicationMetricDescription(
+            name=metric_name,
+            maximum_capacity=maximum_capacity,
+            reservation_capacity=reservation_capacity,
+            total_application_capacity=total_application_capacity))
+
     return res
 
 def create(client,  # pylint: disable=too-many-locals,too-many-arguments
@@ -241,17 +246,20 @@ def create(client,  # pylint: disable=too-many-locals,too-many-arguments
 
     app_metrics = parse_app_metrics(metrics)
 
-    app_cap_desc = ApplicationCapacityDescription(min_node_count,
-                                                  max_node_count,
-                                                  app_metrics)
+    app_cap_desc = ApplicationCapacityDescription(minimum_nodes=min_node_count,
+                                                  maximum_nodes=max_node_count,
+                                                  application_metrics=app_metrics)
 
-    app_desc = ApplicationDescription(app_name, app_type, app_version,
-                                      app_params, app_cap_desc)
+    app_desc = ApplicationDescription(name=app_name,
+                                      type_name=app_type,
+                                      type_version=app_version,
+                                      parameter_list=app_params,
+                                      application_capacity=app_cap_desc)
 
     client.create_application(app_desc, timeout)
 
 def upgrade(  # pylint: disable=too-many-arguments,too-many-locals,missing-docstring
-        client, application_name, application_version, parameters,
+        client, application_id, application_version, parameters,
         mode="UnmonitoredAuto", replica_set_check_timeout=None,
         force_restart=None, failure_action=None,
         health_check_wait_duration="0",
@@ -275,9 +283,12 @@ def upgrade(  # pylint: disable=too-many-arguments,too-many-locals,missing-docst
                                      parse_service_health_policy)
 
     monitoring_policy = MonitoringPolicyDescription(
-        failure_action, health_check_wait_duration,
-        health_check_stable_duration, health_check_retry_timeout,
-        upgrade_timeout, upgrade_domain_timeout
+        failure_action=failure_action,
+        health_check_wait_duration_in_milliseconds=health_check_wait_duration,
+        health_check_stable_duration_in_milliseconds=health_check_stable_duration,
+        health_check_retry_timeout_in_milliseconds=health_check_retry_timeout,
+        upgrade_timeout_in_milliseconds=upgrade_timeout,
+        upgrade_domain_timeout_in_milliseconds=upgrade_domain_timeout
     )
 
     # Must always have empty list
@@ -289,14 +300,21 @@ def upgrade(  # pylint: disable=too-many-arguments,too-many-locals,missing-docst
 
     map_shp = parse_service_health_policy_map(service_health_policy)
 
-    app_health_policy = ApplicationHealthPolicy(warning_as_error,
-                                                max_unhealthy_apps, def_shp,
-                                                map_shp)
-
-    desc = ApplicationUpgradeDescription(application_name, application_version,
-                                         app_params, "Rolling", mode,
-                                         replica_set_check_timeout,
-                                         force_restart, monitoring_policy,
-                                         app_health_policy)
-
-    client.start_application_upgrade(application_name, desc, timeout)
+    app_health_policy = ApplicationHealthPolicy(
+        consider_warning_as_error=warning_as_error,
+        max_percent_unhealthy_deployed_applications=max_unhealthy_apps,
+        default_service_type_health_policy=def_shp,
+        service_type_health_policy_map=map_shp)
+
+    desc = ApplicationUpgradeDescription(
+        name='fabric:/' + application_id,
+        target_application_type_version=application_version,
+        parameters=app_params,
+        upgrade_kind='Rolling',
+        rolling_upgrade_mode=mode,
+        upgrade_replica_set_check_timeout_in_seconds=replica_set_check_timeout,
+        force_restart=force_restart,
+        monitoring_policy=monitoring_policy,
+        application_health_policy=app_health_policy)
+
+    client.start_application_upgrade(application_id, desc, timeout)

src/sfctl/custom_app_type.py

@@ -33,7 +33,7 @@ def provision_application_type(client, #pylint: disable=too-many-locals,invalid-
     from azure.servicefabric.models.external_store_provision_application_type_description \
         import (ExternalStoreProvisionApplicationTypeDescription)
 
-    from azure.servicefabric.models import FabricErrorException
+    from azure.servicefabric.models.fabric_error import FabricErrorException
 
     provision_description = None
 
@@ -49,7 +49,7 @@ def provision_application_type(client, #pylint: disable=too-many-locals,invalid-
                            '--application-package-download-uri, --application-type-name, '
                            '--application-type-version.')
         provision_description = ExternalStoreProvisionApplicationTypeDescription(
-            no_wait,
+            async_property=no_wait,
             application_package_download_uri=application_package_download_uri,
             application_type_name=application_type_name,
             application_type_version=application_type_version)
@@ -65,7 +65,7 @@ def provision_application_type(client, #pylint: disable=too-many-locals,invalid-
                            '--application-type-version.')
 
         provision_description = ProvisionApplicationTypeDescription(
-            no_wait,
+            async_property=no_wait,
             application_type_build_path=application_type_build_path)
 
     api_version = "6.2"

src/sfctl/custom_chaos.py

@@ -40,24 +40,24 @@ def parse_chaos_parameters(chaos_parameters): #pylint: disable=too-many-locals
     chaos_context = chaos_parameters.get("Context")
     context = None
     if chaos_context is not None:
-        context = ChaosContext(chaos_context.get("Map"))
+        context = ChaosContext(map=chaos_context.get("Map"))
 
     chaos_target_filter = chaos_parameters.get("ChaosTargetFilter")
     target_filter = None
     if chaos_target_filter is not None:
         target_filter = ChaosTargetFilter(
-            chaos_target_filter.get("NodeTypeInclusionList"),
-            chaos_target_filter.get("ApplicationTypeInclusionList"))
-
-    return ChaosParameters(time_to_run,
-                           max_cluster_stabilization,
-                           max_concurrent_faults,
-                           enable_move_replica_faults,
-                           wait_time_between_faults,
-                           wait_time_between_iterations,
-                           health_policy,
-                           context,
-                           target_filter)
+            node_type_inclusion_list=chaos_target_filter.get("NodeTypeInclusionList"),
+            application_inclusion_list=chaos_target_filter.get("ApplicationTypeInclusionList"))
+
+    return ChaosParameters(time_to_run_in_seconds=time_to_run,
+                           max_cluster_stabilization_timeout_in_seconds=max_cluster_stabilization,
+                           max_concurrent_faults=max_concurrent_faults,
+                           enable_move_replica_faults=enable_move_replica_faults,
+                           wait_time_between_faults_in_seconds=wait_time_between_faults,
+                           wait_time_between_iterations_in_seconds=wait_time_between_iterations,
+                           cluster_health_policy=health_policy,
+                           context=context,
+                           chaos_target_filter=target_filter)
 
 def parse_chaos_context(formatted_chaos_context):
     """"Parse a chaos context from a formatted context"""
@@ -68,7 +68,7 @@ def parse_chaos_context(formatted_chaos_context):
     if formatted_chaos_context is None:
         return None
 
-    return ChaosContext(formatted_chaos_context)
+    return ChaosContext(map=formatted_chaos_context)
 
 def parse_chaos_target_filter(formatted_chaos_target_filter):
     """"Parse a chaos target filter from a formatted filter"""
@@ -82,7 +82,8 @@ def parse_chaos_target_filter(formatted_chaos_target_filter):
     nodetype_inclusion_list = formatted_chaos_target_filter.get('NodeTypeInclusionList', None) # pylint: disable=line-too-long
     application_inclusion_list = formatted_chaos_target_filter.get('ApplicationInclusionList', None) # pylint: disable=line-too-long
 
-    return ChaosTargetFilter(nodetype_inclusion_list, application_inclusion_list) # pylint: disable=line-too-long
+    return ChaosTargetFilter(node_type_inclusion_list=nodetype_inclusion_list,
+                             application_inclusion_list=application_inclusion_list)
 
 def start(client, time_to_run="4294967295", max_cluster_stabilization=60, #pylint: disable=too-many-arguments,too-many-locals,missing-docstring
           max_concurrent_faults=1, disable_move_replica_faults=False,
@@ -108,23 +109,25 @@ def start(client, time_to_run="4294967295", max_cluster_stabilization=60, #pylin
 
     health_map = parse_app_health_map(app_type_health_policy_map)
 
-    health_policy = ClusterHealthPolicy(warning_as_error,
-                                        max_percent_unhealthy_nodes,
-                                        max_percent_unhealthy_apps,
-                                        health_map)
+    health_policy = ClusterHealthPolicy(
+        consider_warning_as_error=warning_as_error,
+        max_percent_unhealthy_nodes=max_percent_unhealthy_nodes,
+        max_percent_unhealthy_applications=max_percent_unhealthy_apps,
+        application_type_health_policy_map=health_map)
 
     target_filter = parse_chaos_target_filter(chaos_target_filter)
 
     #pylint: disable=too-many-arguments
-    chaos_params = ChaosParameters(time_to_run,
-                                   max_cluster_stabilization,
-                                   max_concurrent_faults,
-                                   not disable_move_replica_faults,
-                                   wait_time_between_faults,
-                                   wait_time_between_iterations,
-                                   health_policy,
-                                   context,
-                                   target_filter)
+    chaos_params = ChaosParameters(
+        time_to_run_in_seconds=time_to_run,
+        max_cluster_stabilization_timeout_in_seconds=max_cluster_stabilization,
+        max_concurrent_faults=max_concurrent_faults,
+        enable_move_replica_faults=not disable_move_replica_faults,
+        wait_time_between_faults_in_seconds=wait_time_between_faults,
+        wait_time_between_iterations_in_seconds=wait_time_between_iterations,
+        cluster_health_policy=health_policy,
+        context=context,
+        chaos_target_filter=target_filter)
     #pylint: enable=too-many-arguments
 
     client.start_chaos(chaos_params, timeout)

src/sfctl/custom_chaos_schedule.py

@@ -24,7 +24,7 @@ def parse_time_of_day(time_of_day):
     if hour is None or minute is None:
         return None
 
-    return TimeOfDay(hour, minute)
+    return TimeOfDay(hour=hour, minute=minute)
 
 def parse_time_range(time_range):
     """
@@ -43,7 +43,7 @@ def parse_time_range(time_range):
 
     # if either start_time or end_time is None, the resulting API call will fail with an exception
 
-    return TimeRange(start_time, end_time)
+    return TimeRange(start_time=start_time, end_time=end_time)
 
 def parse_active_time_ranges(time_ranges):
     """
@@ -84,9 +84,13 @@ def parse_active_days(active_days):
     friday = active_days.get("Friday", False)
     saturday = active_days.get("Saturday", False)
 
-    return ChaosScheduleJobActiveDaysOfWeek(
-        sunday, monday, tuesday, wednesday,
-        thursday, friday, saturday)
+    return ChaosScheduleJobActiveDaysOfWeek(sunday=sunday,
+                                            monday=monday,
+                                            tuesday=tuesday,
+                                            wednesday=wednesday,
+                                            thursday=thursday,
+                                            friday=friday,
+                                            saturday=saturday)
 
 def parse_job(job):
     """
@@ -107,7 +111,9 @@ def parse_job(job):
     active_days = parse_active_days(job.get('Days'))
     times = parse_active_time_ranges(job.get('Times'))
 
-    return ChaosScheduleJob(chaos_parameters, active_days, times)
+    return ChaosScheduleJob(chaos_parameters=chaos_parameters,
+                            days=active_days,
+                            times=times)
 
 def parse_jobs(jobs):
     """
@@ -150,7 +156,7 @@ def parse_chaos_params_dictionary(chaos_parameters_dictionary):
         key = dictionary_entry.get("Key")
         value = parse_chaos_parameters(dictionary_entry.get("Value"))
 
-        parsed_dictionary.append(ChaosParametersDictionaryItem(key, value))
+        parsed_dictionary.append(ChaosParametersDictionaryItem(key=key, value=value))
 
     return parsed_dictionary
 
@@ -178,9 +184,9 @@ def set_chaos_schedule( #pylint: disable=too-many-arguments,too-many-locals
         parse_chaos_params_dictionary(chaos_parameters_dictionary)
     parsed_jobs = parse_jobs(jobs)
 
-    schedule = ChaosSchedule(start_date_utc,
-                             expiry_date_utc,
-                             parsed_chaos_params_dictionary,
-                             parsed_jobs)
+    schedule = ChaosSchedule(start_date=start_date_utc,
+                             expiry_date=expiry_date_utc,
+                             chaos_parameters_dictionary=parsed_chaos_params_dictionary,
+                             jobs=parsed_jobs)
 
     return client.post_chaos_schedule(version, schedule)