}

        private ResolvedCoordinates convertDeclaredCoordinates(String organization, String module, @Nullable String version) {
            if (version == null) {
                warnings.addUnsupported(String.format("%s:%s declared without version", organization, module));
            }

            return ResolvedCoordinates.create(organization, module, version);
        }

	RemoveDuplicateAltNames(&cfg.AltNames)

	template := &x509.CertificateRequest{
		Subject: pkix.Name{
			CommonName:   cfg.CommonName,
			Organization: cfg.Organization,
		},
		DNSNames:    cfg.AltNames.DNSNames,
		IPAddresses: cfg.AltNames.IPs,
	}

	csrBytes, err := x509.CreateCertificateRequest(cryptorand.Reader, template, key)

	if err != nil {

		if len(hostnames) == 0 && len(ips) == 0 {
			return nil
		}
		return &x509.CertificateRequest{
			Subject: pkix.Name{
				CommonName:   fmt.Sprintf("system:node:%s", nodeName),
				Organization: []string{"system:nodes"},
			},
			DNSNames:    hostnames,
			IPAddresses: ips,
		}
	}

	m, err := certificate.NewManager(&certificate.Config{
		ClientsetFn:             clientsetFn,

	if !connected {
		return errors.New("timed out waiting to connect to apiserver")
	}
	return nil
}

// requestNodeCertificate will create a certificate signing request for a node
// (Organization and CommonName for the CSR will be set as expected for node
// certificates) and send it to API server, then it will watch the object's
// status, once approved by API server, it will return the API server's issued

	TTL time.Duration

	// Signer certificate.
	SignerCert *x509.Certificate

	// Signer private key.
	SignerPriv crypto.PrivateKey

	// Signer private key (PEM encoded).
	SignerPrivPem []byte

	// Organization for this certificate.
	Org string

	// The size of RSA private key to be generated.
	RSAKeySize int

	// Whether this certificate is used as signing cert for CA.
	IsCA bool

Now, let's imagine your organization gave you the `app/internal/admin.py` file.

It contains an `APIRouter` with some admin *path operations* that your organization shares between several projects.

    <contributor>
      <name>Mike Mol (MNG-6665)</name>
    </contributor>
    <contributor>
      <name>Martin Kanters</name>
      <organization>JPoint</organization>
    </contributor>
    <contributor>
      <name>Maarten Mulders</name>
      <organization>Info Support</organization>
    </contributor>
    <contributor>
      <name>Luc Klaassen (MNG-6065)</name>
    </contributor>
    <contributor>

		t.Errorf("Unexpected CA certificate TTL (expecting %v, actual %v)", caCertTTL, ttl)
	}

	if certOrg := rootCert.Issuer.Organization[0]; certOrg != org {
		t.Errorf("Unexpected CA certificate organization (expecting %v, actual %v)", org, certOrg)
	}

	if len(certChainBytes) != 0 {
		t.Errorf("Cert chain should be empty")
	}

[[sec:custom_gradle_distribution]]
== Standardizing builds with a custom Gradle distribution

Often enterprises want to standardize the build platform for all projects in the organization by defining common conventions or rules.
You can achieve that with the help of initialization scripts.

====
<1> Make sure your project has a `group` set which is used to identify the artifacts (jar and metadata) you publish for your plugins
in the repository of the {portal} and which is descriptive of the plugin author or the organization the plugins belong too.
<2> Set the version of your project, which will also be used as the version of your plugins.