Pass --cluster option to deploy create

stack_orchestrator/deploy/deployment_create.py

@@ -422,9 +422,10 @@ def _copy_files_to_directory(file_paths: List[Path], directory: Path):
         copy(path, os.path.join(directory, os.path.basename(path)))
 
 
-def _create_deployment_file(deployment_dir: Path):
+def _create_deployment_file(deployment_dir: Path, cluster):
     deployment_file_path = deployment_dir.joinpath(constants.deployment_file_name)
-    cluster = f"{constants.cluster_name_prefix}{token_hex(8)}"
+    if cluster is None:
+        cluster = f"{constants.cluster_name_prefix}{token_hex(8)}"
     with open(deployment_file_path, "w") as output_file:
         output_file.write(f"{constants.cluster_id_key}: {cluster}\n")
 
@@ -473,7 +474,7 @@ def create_operation(deployment_command_context, spec_file, deployment_dir, netw
     # Copy spec file and the stack file into the deployment dir
     copyfile(spec_file, deployment_dir_path.joinpath(constants.spec_file_name))
     copyfile(stack_file, deployment_dir_path.joinpath(constants.stack_file_name))
-    _create_deployment_file(deployment_dir_path)
+    _create_deployment_file(deployment_dir_path, deployment_command_context.cluster_context.cluster)
     # Copy any config varibles from the spec file into an env file suitable for compose
     _write_config_file(spec_file, deployment_dir_path.joinpath(constants.config_file_name))
     # Copy any k8s config file into the deployment dir

stack_orchestrator/deploy/webapp/deploy_webapp_from_registry.py

@@ -54,7 +54,6 @@ def process_app_deployment_request(
     deployment_record_namespace,
     dns_record_namespace,
     default_dns_suffix,
-    dns_value,
     deployment_parent_dir,
     kube_config,
     image_registry,
@@ -252,7 +251,6 @@ def process_app_deployment_request(
         dns_record,
         dns_lrn,
         deployment_dir,
-        dns_value,
         app_deployment_request,
         webapp_deployer_record,
         logger,
@@ -306,7 +304,6 @@ def dump_known_requests(filename, requests, status="SEEN"):
     help="How to handle requests with an FQDN: prohibit, allow, preexisting",
     default="prohibit",
 )
-@click.option("--ip", help="IP address of the k8s deployment (to be set in DNS record)", default=None)
 @click.option("--record-namespace-dns", help="eg, lrn://laconic/dns", required=True)
 @click.option(
     "--record-namespace-deployments",
@@ -342,17 +339,6 @@ def dump_known_requests(filename, requests, status="SEEN"):
     help="Requests must have a minimum payment to be processed (in alnt)",
     default=0,
 )
-@click.option(
-    "--atom-payment-address",
-    help="Cosmos ATOM address to receive payments",
-    default=None,
-)
-@click.option(
-    "--min-atom-payment",
-    help="Minimum required ATOM payment amount",
-    default=1,
-    type=float,
-)
 @click.option("--lrn", help="The LRN of this deployer.", required=True)
 @click.option(
     "--all-requests",
@@ -395,7 +381,6 @@ def command(  # noqa: C901
     only_update_state,
     dns_suffix,
     fqdn_policy,
-    ip,
     record_namespace_dns,
     record_namespace_deployments,
     dry_run,
@@ -405,8 +390,6 @@ def command(  # noqa: C901
     recreate_on_deploy,
     log_dir,
     min_required_payment,
-    atom_payment_address,
-    min_atom_payment,
     lrn,
     config_upload_dir,
     private_key_file,
@@ -446,13 +429,6 @@ def command(  # noqa: C901
         )
         sys.exit(2)
 
-    if fqdn_policy == "allow" and not ip:
-        print(
-            "--ip is required with 'allow' fqdn-policy",
-            file=sys.stderr,
-        )
-        sys.exit(2)
-
     tempdir = tempfile.mkdtemp()
     gpg = gnupg.GPG(gnupghome=tempdir)
 
@@ -643,8 +619,6 @@ def command(  # noqa: C901
                     payment_address,
                     min_required_payment,
                     main_logger,
-                    atom_payment_address,
-                    min_atom_payment,
                 ):
                     main_logger.log(f"{r.id}: Payment confirmed.")
                     requests_to_execute.append(r)
@@ -691,7 +665,6 @@ def command(  # noqa: C901
                         record_namespace_deployments,
                         record_namespace_dns,
                         dns_suffix,
-                        ip,
                         os.path.abspath(deployment_parent_dir),
                         kube_config,
                         image_registry,

stack_orchestrator/deploy/webapp/publish_webapp_deployer.py

@@ -46,17 +46,6 @@ from stack_orchestrator.deploy.webapp.util import LaconicRegistryClient
     help="List the minimum required payment (in alnt) to process a deployment request.",
     default=0,
 )
-@click.option(
-    "--atom-payment-address",
-    help="The Cosmos ATOM address to which payments should be made.",
-    default=None,
-)
-@click.option(
-    "--min-atom-payment",
-    help="List the minimum required payment (in ATOM) to process a deployment request.",
-    default=1,
-    type=float,
-)
 @click.option(
     "--dry-run",
     help="Don't publish anything, just report what would be done.",
@@ -71,8 +60,6 @@ def command(  # noqa: C901
     lrn,
     payment_address,
     min_required_payment,
-    atom_payment_address,
-    min_atom_payment,
     dry_run,
 ):
     laconic = LaconicRegistryClient(laconic_config)
@@ -96,10 +83,6 @@ def command(  # noqa: C901
         webapp_deployer_record["record"][
             "minimumPayment"
         ] = f"{min_required_payment}alnt"
-        
-    if atom_payment_address:
-        webapp_deployer_record["record"]["atomPaymentAddress"] = atom_payment_address
-        webapp_deployer_record["record"]["minimumAtomPayment"] = min_atom_payment
 
     if dry_run:
         yaml.dump(webapp_deployer_record, sys.stdout)

stack_orchestrator/deploy/webapp/util.py

@@ -689,7 +689,6 @@ def publish_deployment(
     dns_record,
     dns_lrn,
     deployment_dir,
-    dns_value=None,
     app_deployment_request=None,
     webapp_deployer_record=None,
     logger=None,
@@ -722,8 +721,6 @@ def publish_deployment(
     }
     if app_deployment_request:
         new_dns_record["record"]["request"] = app_deployment_request.id
-    if dns_value:
-        new_dns_record["record"]["value"] = dns_value
 
     if logger:
         logger.log("Publishing DnsRecord.")
@@ -801,7 +798,7 @@ def skip_by_tag(r, include_tags, exclude_tags):
     return False
 
 
-def confirm_payment(laconic: LaconicRegistryClient, record, payment_address, min_amount, logger, atom_payment_address=None, atom_min_amount=None):
+def confirm_payment(laconic: LaconicRegistryClient, record, payment_address, min_amount, logger):
     req_owner = laconic.get_owner(record)
     if req_owner == payment_address:
         # No need to confirm payment if the sender and recipient are the same account.
@@ -811,114 +808,67 @@ def confirm_payment(laconic: LaconicRegistryClient, record, payment_address, min
         logger.log(f"{record.id}: no payment tx info")
         return False
 
-    # Try to verify as a laconic payment first
     tx = laconic.get_tx(record.attributes.payment)
-    if tx:
-        if tx.code != 0:
-            logger.log(
-                f"{record.id}: payment tx {tx.hash} was not successful - code: {tx.code}, log: {tx.log}"
-            )
-            return False
+    if not tx:
+        logger.log(f"{record.id}: cannot locate payment tx")
+        return False
 
-        if tx.sender != req_owner:
-            logger.log(
-                f"{record.id}: payment sender {tx.sender} in tx {tx.hash} does not match deployment "
-                f"request owner {req_owner}"
-            )
-            return False
-
-        if tx.recipient != payment_address:
-            logger.log(
-                f"{record.id}: payment recipient {tx.recipient} in tx {tx.hash} does not match {payment_address}"
-            )
-            return False
-
-        pay_denom = "".join([i for i in tx.amount if not i.isdigit()])
-        if pay_denom != "alnt":
-            logger.log(
-                f"{record.id}: {pay_denom} in tx {tx.hash} is not an expected payment denomination"
-            )
-            return False
-
-        pay_amount = int("".join([i for i in tx.amount if i.isdigit()]))
-        if pay_amount < min_amount:
-            logger.log(
-                f"{record.id}: payment amount {tx.amount} is less than minimum {min_amount}"
-            )
-            return False
-
-        # Check if the payment was already used on a deployment
-        used = laconic.app_deployments(
-            {"deployer": record.attributes.deployer, "payment": tx.hash}, all=True
+    if tx.code != 0:
+        logger.log(
+            f"{record.id}: payment tx {tx.hash} was not successful - code: {tx.code}, log: {tx.log}"
         )
-        if len(used):
-            # Fetch the app name from request record
-            used_request = laconic.get_record(used[0].attributes.request, require=True)
+        return False
 
-            # Check that payment was used for deployment of same application
-            if record.attributes.application != used_request.attributes.application:
-                logger.log(f"{record.id}: payment {tx.hash} already used on a different application deployment {used}")
-                return False
-
-        used = laconic.app_deployment_removals(
-            {"deployer": record.attributes.deployer, "payment": tx.hash}, all=True
+    if tx.sender != req_owner:
+        logger.log(
+            f"{record.id}: payment sender {tx.sender} in tx {tx.hash} does not match deployment "
+            f"request owner {req_owner}"
         )
-        if len(used):
-            logger.log(
-                f"{record.id}: payment {tx.hash} already used on deployment removal {used}"
-            )
+        return False
+
+    if tx.recipient != payment_address:
+        logger.log(
+            f"{record.id}: payment recipient {tx.recipient} in tx {tx.hash} does not match {payment_address}"
+        )
+        return False
+
+    pay_denom = "".join([i for i in tx.amount if not i.isdigit()])
+    if pay_denom != "alnt":
+        logger.log(
+            f"{record.id}: {pay_denom} in tx {tx.hash} is not an expected payment denomination"
+        )
+        return False
+
+    pay_amount = int("".join([i for i in tx.amount if i.isdigit()]))
+    if pay_amount < min_amount:
+        logger.log(
+            f"{record.id}: payment amount {tx.amount} is less than minimum {min_amount}"
+        )
+        return False
+
+    # Check if the payment was already used on a deployment
+    used = laconic.app_deployments(
+        {"deployer": record.attributes.deployer, "payment": tx.hash}, all=True
+    )
+    if len(used):
+        # Fetch the app name from request record
+        used_request = laconic.get_record(used[0].attributes.request, require=True)
+
+        # Check that payment was used for deployment of same application
+        if record.attributes.application != used_request.attributes.application:
+            logger.log(f"{record.id}: payment {tx.hash} already used on a different application deployment {used}")
             return False
 
-        return True
-    
-    # If we get here, the transaction hash wasn't found in the laconic testnet
-    # Let's check if it's a valid Cosmos ATOM payment if configuration is available
-    if atom_payment_address:
-        logger.log(f"{record.id}: checking if payment is a valid Cosmos ATOM transaction")
-        
-        try:
-            import requests
-            
-            # Use the webapp-deployment-status-api to verify the ATOM payment
-            deployer_record = laconic.get_record(record.attributes.deployer)
-            if not deployer_record or not deployer_record.attributes.apiUrl:
-                logger.log(f"{record.id}: cannot find deployer API URL to verify ATOM payment")
-                return False
-                
-            api_url = deployer_record.attributes.apiUrl
-            verify_url = f"{api_url}/verify/atom-payment"
-            
-            # Make a request to the API to verify the ATOM payment
-            # Pass markAsUsed=true to prevent this transaction from being used again
-            response = requests.post(
-                verify_url,
-                json={
-                    "txHash": record.attributes.payment,
-                    "minAmount": atom_min_amount,
-                    "markAsUsed": True
-                },
-                timeout=10
-            )
-            
-            if response.status_code != 200:
-                logger.log(f"{record.id}: ATOM payment verification API request failed with status {response.status_code}")
-                return False
-                
-            result = response.json()
-            if not result.get("valid", False):
-                logger.log(f"{record.id}: ATOM payment verification failed: {result.get('reason', 'unknown reason')}")
-                return False
-                
-            # Payment is valid
-            logger.log(f"{record.id}: ATOM payment verified successfully, amount: {result.get('amount')} ATOM")
-            return True
-            
-        except Exception as e:
-            logger.log(f"{record.id}: error verifying ATOM payment: {str(e)}")
-            return False
-    
-    logger.log(f"{record.id}: payment tx {record.attributes.payment} not found in laconic testnet and ATOM payment verification not configured")
-    return False
+    used = laconic.app_deployment_removals(
+        {"deployer": record.attributes.deployer, "payment": tx.hash}, all=True
+    )
+    if len(used):
+        logger.log(
+            f"{record.id}: payment {tx.hash} already used on deployment removal {used}"
+        )
+        return False
+
+    return True
 
 
 def confirm_auction(laconic: LaconicRegistryClient, record, deployer_lrn, payment_address, logger):