func newGoogleCDNStorageMiddleware()

in registry/storage/driver/middleware/googlecdn/middleware.go [54:164]
96 lines of code
25 McCabe index (conditional complexity)

func newGoogleCDNStorageMiddleware(storageDriver driver.StorageDriver, options map[string]any) (driver.StorageDriver, error) {
	// parse baseurl
	base, ok := options["baseurl"]
	if !ok {
		return nil, fmt.Errorf("no baseurl provided")
	}
	baseURL, ok := base.(string)
	if !ok {
		return nil, fmt.Errorf("baseurl must be a string")
	}
	if !strings.Contains(baseURL, "://") {
		baseURL = "https://" + baseURL
	}
	if !strings.HasSuffix(baseURL, "/") {
		baseURL += "/"
	}
	if _, err := url.Parse(baseURL); err != nil {
		return nil, fmt.Errorf("invalid baseurl: %v", err)
	}

	// parse privatekey
	pk, ok := options["privatekey"]
	if !ok {
		return nil, fmt.Errorf("no privatekey provided")
	}
	keyName, ok := pk.(string)
	if !ok {
		return nil, fmt.Errorf("privatekey must be a string")
	}
	key, err := readKeyFile(keyName)
	if err != nil {
		return nil, fmt.Errorf("failed to read privatekey file: %s", err)
	}

	// parse keyname
	v, ok := options["keyname"]
	if !ok {
		return nil, fmt.Errorf("no keyname provided")
	}
	pkName, ok := v.(string)
	if !ok {
		return nil, fmt.Errorf("keyname must be a string")
	}

	urlSigner := newURLSigner(pkName, key)

	// parse duration
	duration := defaultDuration
	if d, ok := options["duration"]; ok {
		switch d := d.(type) {
		case time.Duration:
			duration = d
		case string:
			dur, err := time.ParseDuration(d)
			if err != nil {
				return nil, fmt.Errorf("invalid duration: %s", err)
			}
			duration = dur
		}
	}

	// parse updatefrequency
	updateFrequency := defaultUpdateFrequency
	if v, ok := options["updatefrequency"]; ok {
		switch v := v.(type) {
		case time.Duration:
			updateFrequency = v
		case string:
			d, err := time.ParseDuration(v)
			if err != nil {
				return nil, fmt.Errorf("invalid updatefrequency: %s", err)
			}
			updateFrequency = d
		}
	}

	// parse iprangesurl
	ipRangesURL := defaultIPRangesURL
	if v, ok := options["iprangesurl"]; ok {
		s, ok := v.(string)
		if !ok {
			return nil, fmt.Errorf("iprangesurl must be a string")
		}
		ipRangesURL = s
	}

	// parse ipfilteredby
	var googleIPs *googleIPs
	if v, ok := options["ipfilteredby"]; ok {
		ipFilteredBy, ok := v.(string)
		if !ok {
			return nil, fmt.Errorf("ipfilteredby must be a string")
		}
		switch strings.ToLower(strings.TrimSpace(ipFilteredBy)) {
		case "", "none":
			googleIPs = nil
		case "gcp":
			googleIPs = newGoogleIPs(ipRangesURL, updateFrequency)
		default:
			return nil, fmt.Errorf("ipfilteredby must be one of the following values: none|gcp")
		}
	}

	return &googleCDNStorageMiddleware{
		StorageDriver: storageDriver,
		urlSigner:     urlSigner,
		baseURL:       baseURL,
		duration:      duration,
		googleIPs:     googleIPs,
	}, nil
}