uffizzi-cli 0.11.3 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 180b017f63db77067a36ac80286e244bed3c363e9c884c6c65e7f0157c5342dd
-  data.tar.gz: 024ad78f5e85209b2970324f68b8017f1a9fb919e3c9b7dcfbc31ef903dad548
+  metadata.gz: c27a1f65cd69d407dc2f086733a20baaf6e129b7433322ac61682f6b8a1fa54e
+  data.tar.gz: 61c6860dbc035009ee6197f353c05d0af95eda6d6f77b67d25f672ba954e114f
 SHA512:
-  metadata.gz: d2c0eb580b2b290b03bbbab9069020b150929cdeb3eeca9ec10bd238b9325a48c77716b19f30e638435ad00c9c406a6d0d4bfa7049aa63afc7861233700d71a3
-  data.tar.gz: 39bc279bb44a2ed422220d517fe104942efb17ccbcc0a7ee58bb0698b923aea2396d3cc493303cadc92cc723cba8114dde62bc3a9c4564e7e6e3b53ff17ac7d2
+  metadata.gz: 709d000e6701f32d3dcaa3745c68d2eb63695dba2dd8ef939201569605bb121fdd3422d730d3bdc2687a33cc81810b97a3a4f4841187aac68547824293523173
+  data.tar.gz: 1b0ae241adab3fb770f25cca8709ae779b5c8de16056fa71e6242d470123550b6cacc920f1e2b9474951323b72d1d18160a840ed64c4814469eb89e138d0c3d5

data/config/uffizzi.rb

@@ -19,6 +19,7 @@ module Uffizzi
       google: 'UffizziCore::Credential::Google',
       amazon: 'UffizziCore::Credential::Amazon',
       github_registry: 'UffizziCore::Credential::GithubContainerRegistry',
+      docker_registry: 'UffizziCore::Credential::DockerRegistry',
     }
     config.default_server = 'app.uffizzi.com'
   end

data/lib/uffizzi/cli/connect.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'uffizzi'
+require 'uffizzi/helpers/connect_helper'
 
 module Uffizzi
   class Cli::Connect < Thor
@@ -20,39 +21,76 @@ module Uffizzi
     desc 'docker-hub', 'Connect to Docker Hub (hub.docker.com)'
     method_option :skip_raise_existence_error, type: :boolean, default: false,
                                                desc: 'Skip raising an error within check the credential'
+    method_option :update_credential_if_exists, type: :boolean, default: false
+    method_option :username, type: :string, aliases: :u
+    method_option :password, type: :string, aliases: :p
     def docker_hub
       type = Uffizzi.configuration.credential_types[:dockerhub]
-      check_credential_existence(type, 'docker-hub')
+      credential_exists = credential_exists?(type)
+      handle_existing_credential_options('docker-hub') if credential_exists
 
-      username = ENV['DOCKERHUB_USERNAME'] || Uffizzi.ui.ask('Username: ')
-      password = ENV['DOCKERHUB_PASSWORD'] || Uffizzi.ui.ask('Password: ', echo: false)
+      username, password = Uffizzi::ConnectHelper.get_docker_hub_data(options)
 
       params = {
         username: username,
         password: password,
-        type: Uffizzi.configuration.credential_types[:dockerhub],
+        type: type,
       }
+      server = ConfigFile.read_option(:server)
+
+      response = if credential_exists
+        update_credential(server, params, type)
+      else
+        create_credential(server, params)
+      end
 
+      handle_result_for('Docker Hub', response)
+    end
+
+    desc 'docker-registry', 'Connect to any registry implementing the Docker Registry HTTP API protocol'
+    method_option :skip_raise_existence_error, type: :boolean, default: false,
+                                               desc: 'Skip raising an error within check the credential'
+    method_option :update_credential_if_exists, type: :boolean, default: false
+    method_option :registry, type: :string, aliases: :r
+    method_option :username, type: :string, aliases: :u
+    method_option :password, type: :string, aliases: :p
+    def docker_registry
+      type = Uffizzi.configuration.credential_types[:docker_registry]
+      credential_exists = credential_exists?(type)
+      handle_existing_credential_options('docker-registry') if credential_exists
+
+      registry_url, username, password = Uffizzi::ConnectHelper.get_docker_registry_data(options)
+
+      params = {
+        registry_url: prepare_registry_url(registry_url),
+        username: username,
+        password: password,
+        type: type,
+      }
       server = ConfigFile.read_option(:server)
-      response = create_credential(server, params)
 
-      if ResponseHelper.created?(response)
-        print_success_message('DockerHub')
+      response = if credential_exists
+        update_credential(server, params, type)
       else
-        ResponseHelper.handle_failed_response(response)
+        create_credential(server, params)
       end
+
+      handle_result_for('Docker Registry', response)
     end
 
     desc 'acr', 'Connect to Azure Container Registry (azurecr.io)'
     method_option :skip_raise_existence_error, type: :boolean, default: false,
                                                desc: 'Skip raising an error within check the credential'
+    method_option :update_credential_if_exists, type: :boolean, default: false
+    method_option :registry, type: :string, aliases: :r
+    method_option :username, type: :string, aliases: :u
+    method_option :password, type: :string, aliases: :p
     def acr
       type = Uffizzi.configuration.credential_types[:azure]
-      check_credential_existence(type, 'acr')
+      credential_exists = credential_exists?(type)
+      handle_existing_credential_options('acr') if credential_exists
 
-      registry_url = ENV['ACR_REGISTRY_URL'] || Uffizzi.ui.ask('Registry Domain: ')
-      username = ENV['ACR_USERNAME'] || Uffizzi.ui.ask('Docker ID: ')
-      password = ENV['ACR_PASSWORD'] || Uffizzi.ui.ask('Password/Access Token: ', echo: false)
+      registry_url, username, password = Uffizzi::ConnectHelper.get_acr_data(options)
 
       params = {
         username: username,
@@ -60,51 +98,56 @@ module Uffizzi
         registry_url: prepare_registry_url(registry_url),
         type: type,
       }
-
       server = ConfigFile.read_option(:server)
-      response = create_credential(server, params)
 
-      if ResponseHelper.created?(response)
-        print_success_message('ACR')
+      response = if credential_exists
+        update_credential(server, params, type)
       else
-        ResponseHelper.handle_failed_response(response)
+        create_credential(server, params)
       end
+
+      handle_result_for('ACR', response)
     end
 
     desc 'ecr', 'Connect to Amazon Elastic Container Registry'
     method_option :skip_raise_existence_error, type: :boolean, default: false,
                                                desc: 'Skip raising an error within check the credential'
+    method_option :update_credential_if_exists, type: :boolean, default: false
+    method_option :registry, type: :string, aliases: :r
+    method_option :id, type: :string
+    method_option :secret, type: :string, aliases: :s
     def ecr
       type = Uffizzi.configuration.credential_types[:amazon]
-      check_credential_existence(type, 'ecr')
+      credential_exists = credential_exists?(type)
+      handle_existing_credential_options('ecr') if credential_exists
 
-      registry_url = ENV['AWS_REGISTRY_URL'] || Uffizzi.ui.ask('Registry Domain: ')
-      access_key = ENV['AWS_ACCESS_KEY_ID'] || Uffizzi.ui.ask('Access key ID: ')
-      secret_access_key = ENV['AWS_SECRET_ACCESS_KEY'] || Uffizzi.ui.ask('Secret access key: ', echo: false)
+      registry_url, access_key_id, secret_access_key = Uffizzi::ConnectHelper.get_ecr_data(options)
 
       params = {
-        username: access_key,
+        username: access_key_id,
         password: secret_access_key,
         registry_url: prepare_registry_url(registry_url),
         type: type,
       }
-
       server = ConfigFile.read_option(:server)
-      response = create_credential(server, params)
 
-      if ResponseHelper.created?(response)
-        print_success_message('ECR')
+      response = if credential_exists
+        update_credential(server, params, type)
       else
-        ResponseHelper.handle_failed_response(response)
+        create_credential(server, params)
       end
+
+      handle_result_for('ECR', response)
     end
 
     desc 'gcr', 'Connect to Google Container Registry (gcr.io)'
     method_option :skip_raise_existence_error, type: :boolean, default: false,
                                                desc: 'Skip raising an error within check the credential'
+    method_option :update_credential_if_exists, type: :boolean, default: false
     def gcr(credential_file_path = nil)
       type = Uffizzi.configuration.credential_types[:google]
-      check_credential_existence(type, 'gcr')
+      credential_exists = credential_exists?(type)
+      handle_existing_credential_options('gcr') if credential_exists
 
       credential_content = google_service_account_content(credential_file_path)
 
@@ -112,71 +155,88 @@ module Uffizzi
         password: credential_content,
         type: type,
       }
-
       server = ConfigFile.read_option(:server)
-      response = create_credential(server, params)
 
-      if ResponseHelper.created?(response)
-        print_success_message('GCR')
+      response = if credential_exists
+        update_credential(server, params, type)
       else
-        ResponseHelper.handle_failed_response(response)
+        create_credential(server, params)
       end
+
+      handle_result_for('GCR', response)
     end
 
     desc 'ghcr', 'Connect to GitHub Container Registry (ghcr.io)'
     method_option :skip_raise_existence_error, type: :boolean, default: false,
                                                desc: 'Skip raising an error within check the credential'
+    method_option :update_credential_if_exists, type: :boolean, default: false
     method_option :username, type: :string, aliases: :u
     method_option :token, type: :string, aliases: :t
     def ghcr
       type = Uffizzi.configuration.credential_types[:github_registry]
-      check_credential_existence(type, 'ghcr')
+      credential_exists = credential_exists?(type)
+      handle_existing_credential_options('ghcr') if credential_exists
 
-      username = options[:username] || ENV['GITHUB_USERNAME'] || Uffizzi.ui.ask('Github Username:')
-      password = options[:token] || ENV['GITHUB_ACCESS_TOKEN'] || Uffizzi.ui.ask('Access Token:', echo: false)
+      username, password = Uffizzi::ConnectHelper.get_ghcr_data(options)
 
       params = {
         username: username,
         password: password,
         type: type,
       }
-
       server = ConfigFile.read_option(:server)
-      response = create_credential(server, params)
 
-      if ResponseHelper.created?(response)
-        print_success_message('GHCR')
+      response = if credential_exists
+        update_credential(server, params, type)
       else
-        ResponseHelper.handle_failed_response(response)
+        create_credential(server, params)
       end
+
+      handle_result_for('GHCR', response)
     end
 
     map 'list-credentials' => 'list_credentials'
     map 'docker-hub' => 'docker_hub'
+    map 'docker-registry' => 'docker_registry'
 
     private
 
+    def handle_result_for(credential_type, response)
+      if ResponseHelper.created?(response) || ResponseHelper.ok?(response)
+        print_success_message(credential_type)
+      else
+        ResponseHelper.handle_failed_response(response)
+      end
+    end
+
     def prepare_registry_url(registry_url)
       return registry_url if registry_url.match?(/^(?:http(s)?:\/\/)/)
 
       "https://#{registry_url}"
     end
 
-    def print_success_message(connection_name)
-      Uffizzi.ui.say("Successfully connected to #{connection_name}")
+    def print_success_message(credential_type)
+      Uffizzi.ui.say("Successfully connected to #{credential_type}.")
     end
 
-    def check_credential_existence(type, connection_name)
+    def credential_exists?(type)
       server = ConfigFile.read_option(:server)
       response = check_credential(server, type)
-      return if ResponseHelper.ok?(response)
+      !ResponseHelper.ok?(response)
+    end
+
+    def handle_existing_credential_options(credential_type_slug)
+      if options.update_credential_if_exists?
+        Uffizzi.ui.say('Updating existing credential.')
+        return
+      end
 
       if options.skip_raise_existence_error?
-        Uffizzi.ui.say("Credentials of type #{connection_name} already exist for this account.")
+        Uffizzi.ui.say("Credential of type #{credential_type_slug} already exists for this account.")
         exit(true)
       else
-        message = "Credentials of type #{connection_name} already exist for this account. " \
-        "To remove them, run $ uffizzi disconnect #{connection_name}."
+        message = "Credential of type #{credential_type_slug} already exists for this account.\n" \
+        "To remove them, run uffizzi disconnect #{credential_type_slug}."
         raise Uffizzi::Error.new(message)
       end
     end
@@ -204,7 +264,7 @@ module Uffizzi
     def google_service_account_content(credential_file_path = nil)
       return ENV['GCLOUD_SERVICE_KEY'] if ENV['GCLOUD_SERVICE_KEY']
 
-      return Uffizzi.ui.say('Path to google service account key file wasn\'t specified.') if credential_file_path.nil?
+      raise Uffizzi::Error.new("Path to a google service account key file wasn't specified.") if credential_file_path.nil?
 
       begin
         credential_content = File.read(credential_file_path)

data/lib/uffizzi/cli/disconnect.rb

@@ -10,6 +10,8 @@ module Uffizzi
       connection_type = case credential_type
                         when 'docker-hub'
                           Uffizzi.configuration.credential_types[:dockerhub]
+                        when 'docker-registry'
+                          Uffizzi.configuration.credential_types[:docker_registry]
                         when 'acr'
                           Uffizzi.configuration.credential_types[:azure]
                         when 'ecr'
@@ -25,7 +27,7 @@ module Uffizzi
       response = delete_credential(ConfigFile.read_option(:server), connection_type)
 
       if ResponseHelper.no_content?(response)
-        Uffizzi.ui.say("Successfully disconnected #{connection_name(credential_type)} connection")
+        Uffizzi.ui.say("Successfully disconnected from #{connection_name(credential_type)}.")
       else
         ResponseHelper.handle_failed_response(response)
       end
@@ -36,6 +38,7 @@ module Uffizzi
     def connection_name(credential_type)
       {
         'docker-hub' => 'DockerHub',
+        'docker-registry' => 'Docker Registry',
         'acr' => 'ACR',
         'ecr' => 'ECR',
         'gcr' => 'GCR',

data/lib/uffizzi/clients/api/api_client.rb

@@ -70,6 +70,13 @@ module ApiClient
     build_response(response)
   end
 
+  def update_credential(server, params, type)
+    uri = credential_uri(server, type)
+    response = http_client.make_put_request(uri, params)
+
+    build_response(response)
+  end
+
   def fetch_deployment_services(server, project_slug, deployment_id)
     uri = preview_services_uri(server, project_slug, deployment_id)
     response = http_client.make_get_request(uri)
@@ -78,7 +85,7 @@ module ApiClient
   end
 
   def delete_credential(server, credential_type)
-    uri = delete_credential_uri(server, credential_type)
+    uri = credential_uri(server, credential_type)
     response = http_client.make_delete_request(uri)
 
     build_response(response)

data/lib/uffizzi/clients/api/api_routes.rb

@@ -64,7 +64,7 @@ module ApiRoutes
     "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers"
   end
 
-  def delete_credential_uri(server, credential_type)
+  def credential_uri(server, credential_type)
     "#{server}/api/cli/v1/account/credentials/#{credential_type}"
   end
 

data/lib/uffizzi/helpers/connect_helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Uffizzi
+  module ConnectHelper
+    class << self
+      def get_docker_registry_data(options)
+        registry_url = options[:registry] || ENV['DOCKER_REGISTRY_URL'] || Uffizzi.ui.ask('Registry Domain:')
+        username = options[:username] || ENV['DOCKER_REGISTRY_USERNAME'] || Uffizzi.ui.ask('Username:')
+        password = options[:password] || ENV['DOCKER_REGISTRY_PASSWORD'] || Uffizzi.ui.ask('Password:', echo: false)
+
+        [registry_url, username, password]
+      end
+
+      def get_docker_hub_data(options)
+        username = options[:username] || ENV['DOCKERHUB_USERNAME'] || Uffizzi.ui.ask('Username:')
+        password = options[:password] || ENV['DOCKERHUB_PASSWORD'] || Uffizzi.ui.ask('Password:', echo: false)
+
+        [username, password]
+      end
+
+      def get_acr_data(options)
+        registry_url = options[:registry] || ENV['ACR_REGISTRY_URL'] || Uffizzi.ui.ask('Registry Domain:')
+        username = options[:username] || ENV['ACR_USERNAME'] || Uffizzi.ui.ask('Docker ID:')
+        password = options[:password] || ENV['ACR_PASSWORD'] || Uffizzi.ui.ask('Password/Access Token:', echo: false)
+
+        [registry_url, username, password]
+      end
+
+      def get_ecr_data(options)
+        registry_url = options[:registry] || ENV['AWS_REGISTRY_URL'] || Uffizzi.ui.ask('Registry Domain:')
+        access_key_id = options[:id] || ENV['AWS_ACCESS_KEY_ID'] || Uffizzi.ui.ask('Access key ID:')
+        secret_access_key = options[:secret] || ENV['AWS_SECRET_ACCESS_KEY'] || Uffizzi.ui.ask('Secret access key:', echo: false)
+
+        [registry_url, access_key_id, secret_access_key]
+      end
+
+      def get_ghcr_data(options)
+        username = options[:username] || ENV['GITHUB_USERNAME'] || Uffizzi.ui.ask('Github Username:')
+        password = options[:token] || ENV['GITHUB_ACCESS_TOKEN'] || Uffizzi.ui.ask('Access Token:', echo: false)
+
+        [username, password]
+      end
+    end
+  end
+end

data/lib/uffizzi/services/compose_file_service.rb

@@ -92,7 +92,7 @@ class ComposeFileService
 
     def parse_compose_content_to_object(compose_content)
       begin
-        compose_data = Psych.safe_load(compose_content)
+        compose_data = Psych.safe_load(compose_content, aliases: true)
       rescue Psych::SyntaxError
         Uffizzi.ui.say('Invalid compose file')
       end

data/lib/uffizzi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Uffizzi
-  VERSION = '0.11.3'
+  VERSION = '0.12.0'
 end

data/man/uffizzi-connect

@@ -1,37 +1,42 @@
 .\" generated with Ronn-NG/v0.9.1
 .\" http://github.com/apjanke/ronn-ng/tree/0.9.1
-.TH "UFFIZZI\-CONNECT" "" "July 2022" ""
+.TH "UFFIZZI\-CONNECT" "" "August 2022" ""
 .SH "NAME"
 \fBuffizzi\-connect\fR \- grant a Uffizzi user account access to external services
 .SH "SYNOPSIS"
-.nf
-uffizzi connect COMMAND
-.fi
+\fBuffizzi connect\fR COMMAND [\-\-skip\-raise\-existence\-error] [\-\-update\-credential\-if\-exists]
 .SH "DESCRIPTION"
-.nf
-Grants a Uffizzi user account access to external services
-
+Grants a Uffizzi user account access to external services\.
+.P
 For more information on connecting to external services, see:
+.br
 https://github\.com/UffizziCloud/uffizzi_cli
-.fi
 .SH "COMMANDS"
-.nf
 COMMAND is one of the following:
-
-acr
-    Connect to Azure Container Registry (azurecr\.io)\.
-
-docker\-hub
-    Connect to Docker Hub (hub\.docker\.com)\.
-
-ecr
-    Connect to Amazon Elastic Container Registry (amazonaws\.com)\.
-
-gcr
-    Connect to Google Container Registry (gcr\.io)\.
-
-ghcr
-    Connect to GitHub Container Registry (ghcr\.io)\.
-.fi
+.TP
+\fBacr\fR
+Connect to Azure Container Registry (azurecr\.io)\.
+.TP
+\fBdocker\-hub\fR
+Connect to Docker Hub (hub\.docker\.com)\.
+.TP
+\fBdocker\-registry\fR
+Connect to any registry implementing the Docker Registry HTTP API protocol
+.TP
+\fBecr\fR
+Connect to Amazon Elastic Container Registry (amazonaws\.com)\.
+.TP
+\fBgcr\fR
+Connect to Google Container Registry (gcr\.io)\.
+.TP
+\fBghcr\fR
+Connect to GitHub Container Registry (ghcr\.io)\.
+.SH "FLAGS"
+.TP
+\fB\-\-skip\-raise\-existence\-error\fR
+If credential exists, do not raise an exception, just print a message\.
+.TP
+\fB\-\-update\-credential\-if\-exists\fR
+Update credential if it exists\.
 .P
-Run \'uffizzi connect COMMAND \-\-help\' for more information on a command\.
+Run \fBuffizzi connect COMMAND \-\-help\fR for more information on a command\.

data/man/uffizzi-connect-acr

@@ -1,35 +1,37 @@
 .\" generated with Ronn-NG/v0.9.1
 .\" http://github.com/apjanke/ronn-ng/tree/0.9.1
-.TH "UFFIZZI\-CONNECT\-ACR" "" "May 2022" ""
+.TH "UFFIZZI\-CONNECT\-ACR" "" "August 2022" ""
 .SH "NAME"
 \fBuffizzi\-connect\-acr\fR \- grant a Uffizzi user account access to a private Azure Container Registry (ACR)
 .SH "SYNOPSIS"
-.nf
-uffizzi connect acr
-.fi
+\fBuffizzi connect acr\fR [\-\-registry=REGISTRY] [\-\-username=USERNAME] [\-\-password=PASSWORD]
 .SH "DESCRIPTION"
-.nf
-Given valid credentials, grants a Uffizzi user account access
-to a private Azure Container Registry
-
-This command can fail for the following reasons:
-    \- The active user does not have permission to connect
-      external services\.
-    \- The given credentials are invalid\.
-
+Given valid credentials, grants a Uffizzi user account access to a private Azure Container Registry
+.P
+Credentials can be provided interactively or non\-interactively via command options or environment variables:
+.br
+\fBACR_REGISTRY_URL\fR, \fBACR_REGISTRY_USERNAME\fR, \fBACR_REGISTRY_PASSWORD\fR
+.P
+This command can fail for the following reasons: \- The active user does not have permission to connect external services\. \- The given credentials are invalid\.
+.P
 For more information on connecting to external services, see:
+.br
 https://github\.com/UffizziCloud/uffizzi_cli
-
-For detailed instructions on configuring webhooks to send push
-notifications to Uffizzi, see
+.P
+For detailed instructions on configuring webhooks to send push notifications to Uffizzi, see:
+.br
 https://docs\.uffizzi\.com/guides/container\-registry\-integrations
-.fi
+.SH "OPTIONS"
+.TP
+\fB\-r\fR, \fB\-\-registry=<registry>\fR
+URL of the service\.
+.TP
+\fB\-u\fR, \fB\-\-username=<username>\fR
+Username for the service\.
+.TP
+\fB\-p\fR, \fB\-\-password=<password>\fR
+Password for the service\.
 .SH "EXAMPLES"
-.nf
-The following command will prompt the user to enter ACR
-credentials, including registry domain, Docker ID and
-password or access token:
-
-    $ uffizzi connect acr
-.fi
-
+The following command will prompt the user to enter ACR credentials, including registry domain, Docker ID and password or access token:
+.P
+\fBuffizzi connect acr\fR

data/man/uffizzi-connect-acr.ronn

@@ -1,28 +1,42 @@
-uffizzi-connect-acr - grant a Uffizzi user account access to a private Azure Container Registry (ACR)
-================================================================
+# uffizzi-connect-acr - grant a Uffizzi user account access to a private Azure Container Registry (ACR)
 
 ## SYNOPSIS
-    uffizzi connect acr
+
+`uffizzi connect acr` [--registry=REGISTRY] [--username=USERNAME] [--password=PASSWORD]
 
 ## DESCRIPTION
-    Given valid credentials, grants a Uffizzi user account access 
-    to a private Azure Container Registry
 
-    This command can fail for the following reasons:
-        - The active user does not have permission to connect 
-          external services.
-        - The given credentials are invalid.
+Given valid credentials, grants a Uffizzi user account access 
+to a private Azure Container Registry
+
+Credentials can be provided interactively or non-interactively
+via command options or environment variables:  
+`ACR_REGISTRY_URL`, `ACR_REGISTRY_USERNAME`, `ACR_REGISTRY_PASSWORD`
+
+This command can fail for the following reasons:
+- The active user does not have permission to connect external services.
+- The given credentials are invalid.
+
+For more information on connecting to external services, see:  
+https://github.com/UffizziCloud/uffizzi_cli
 
-    For more information on connecting to external services, see:
-    https://github.com/UffizziCloud/uffizzi_cli
+For detailed instructions on configuring webhooks to send push
+notifications to Uffizzi, see:  
+https://docs.uffizzi.com/guides/container-registry-integrations
 
-    For detailed instructions on configuring webhooks to send push
-    notifications to Uffizzi, see 
-    https://docs.uffizzi.com/guides/container-registry-integrations
+## OPTIONS
+
+* `-r`, `--registry=<registry>`:
+  URL of the service.
+* `-u`, `--username=<username>`:
+  Username for the service.
+* `-p`, `--password=<password>`:
+  Password for the service.
 
 ## EXAMPLES
-    The following command will prompt the user to enter ACR 
-    credentials, including registry domain, Docker ID and 
-    password or access token:
-          
-        $ uffizzi connect acr
+
+The following command will prompt the user to enter ACR 
+credentials, including registry domain, Docker ID and 
+password or access token:
+
+`uffizzi connect acr`