I managed to solve the issue by creating a custom cloneAuth function, based on v3auth.

// global client
var client *gophercloud.ProviderClient
// shared auth options
var ao *gophercloud.AuthOptions

func cloneAuth(c *gophercloud.ProviderClient, endpoint string, opts tokens3.AuthOptionsBuilder, eo gophercloud.EndpointOpts, reauth bool) error {
        // Override the generated service endpoint with the one returned by the version endpoint.
        v3Client, err := openstack.NewIdentityV3(c, eo)
        if err != nil {
                return err
        }

        if endpoint != "" {
                v3Client.Endpoint = endpoint
        }

        if reauth {
                var result tokens3.CreateResult
                switch opts.(type) {
                case *ec2tokens.AuthOptions:
                        result = ec2tokens.Create(v3Client, opts)
                case *oauth1.AuthOptions:
                        result = oauth1.Create(v3Client, opts)
                default:
                        result = tokens3.Create(v3Client, opts)
                }

                err = c.SetTokenAndAuthResult(result)
                if err != nil {
                        return err
                }

                catalog, err := result.ExtractServiceCatalog()
                if err != nil {
                        return err
                }

                c.EndpointLocator = func(opts gophercloud.EndpointOpts) (string, error) {
                        return openstack.V3EndpointURL(catalog, opts)
                }
        }

        if opts.CanReauth() {
                // here we're creating a throw-away client (tac). it's a copy of the user's provider client, but
                // with the token and reauth func zeroed out. combined with setting `AllowReauth` to `false`,
                // this should retry authentication only once
                tac := *c
                tac.SetThrowaway(true)
                tac.ReauthFunc = nil
                tac.SetTokenAndAuthResult(nil)
                var tao tokens3.AuthOptionsBuilder
                switch ot := opts.(type) {
                case *gophercloud.AuthOptions:
                        o := *ot
                        o.AllowReauth = false
                        tao = &o
                case *tokens3.AuthOptions:
                        o := *ot
                        o.AllowReauth = false
                        tao = &o
                case *ec2tokens.AuthOptions:
                        o := *ot
                        o.AllowReauth = false
                        tao = &o
                case *oauth1.AuthOptions:
                        o := *ot
                        o.AllowReauth = false
                        tao = &o
                default:
                        tao = opts
                }
                c.ReauthFunc = func() error {
                        err := cloneAuth(&tac, endpoint, tao, eo, true)
                        if err != nil {
                                return err
                        }
                        c.CopyTokenFrom(&tac)

                        // update the token for the source provider
                        lock.Lock()
                        client.CopyTokenFrom(&tac)
                        lock.Unlock()

                        return nil
                }
        }

        return nil
}

func cloneProvider(requestID string) (*gophercloud.ProviderClient, *DefaultLogger, error) {
        // initialize a provider client
        provider, err := openstack.NewClient(client.IdentityEndpoint)
        if err != nil {
                return nil, nil, fmt.Errorf("failed to create an OpenStack service client: %s", err)
        }

        var logger *DefaultLogger
        if debug {
                logger = &DefaultLogger{requestID}
                provider.HTTPClient = http.Client{
                        Transport: &RoundTripper{
                                Rt:     &http.Transport{},
                                Logger: logger,
                        },
                }
        }

        provider.TokenID = client.TokenID
        provider.EndpointLocator = client.EndpointLocator
        err = cloneAuth(provider, "", ao, gophercloud.EndpointOpts{}, false)
        if err != nil {
                return nil, nil, fmt.Errorf("failed to auth an OpenStack service client: %s", err)
        }

        return provider, logger, nil
}

func someFunc() {
        ... ... ...
        // clone a provider client
        provider, logger, err := cloneProvider(requestID)
        if err != nil {
                return nil, err
        }
        ... ... ...
}

Core: DeepCopy method for the provider client #1987

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions