• Home
• com.redhat.red.build
• kojiji
• 2.9
• source code
• KojiClient.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.redhat.red.build.koji.KojiClient Maven / Gradle / Ivy

/**
 * Copyright (C) 2015 Red Hat, Inc. ([email protected])
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.redhat.red.build.koji;

import com.codahale.metrics.MetricRegistry;
import com.redhat.red.build.koji.config.KojiConfig;
import com.redhat.red.build.koji.kerberos.KrbAuthenticator;
import com.redhat.red.build.koji.model.ImportFile;
import com.redhat.red.build.koji.model.KojiImportResult;
import com.redhat.red.build.koji.model.generated.Model_Registry;
import com.redhat.red.build.koji.model.json.KojiImport;
import com.redhat.red.build.koji.model.json.util.KojiObjectMapper;
import com.redhat.red.build.koji.model.xmlrpc.*;
import com.redhat.red.build.koji.model.xmlrpc.messages.*;

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ConnectionPoolTimeoutException;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.commonjava.atlas.maven.ident.ref.ProjectRef;
import org.commonjava.atlas.maven.ident.ref.ProjectVersionRef;
import org.commonjava.rwx.api.RWXMapper;
import org.commonjava.rwx.core.Registry;
import org.commonjava.rwx.error.XmlRpcException;
import com.redhat.red.build.koji.http.RequestModifier;
import com.redhat.red.build.koji.http.UrlBuildResult;
import com.redhat.red.build.koji.http.UrlBuilder;
import com.redhat.red.build.koji.http.httpclient4.HC4SyncObjectClient;
import org.commonjava.util.jhttpc.HttpFactory;
import org.commonjava.util.jhttpc.JHttpCException;
import org.commonjava.util.jhttpc.auth.PasswordManager;
import org.commonjava.util.jhttpc.util.UrlUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URLEncoder;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Supplier;
import java.util.stream.Collectors;

import javax.security.auth.DestroyFailedException;

import static com.redhat.red.build.koji.KojiClientUtils.buildMultiCallRequest;
import static com.redhat.red.build.koji.KojiClientUtils.parseMultiCallResponse;
import static com.redhat.red.build.koji.model.util.KojiFormats.toKojiName;
import static com.redhat.red.build.koji.model.xmlrpc.KojiBuildTypeInfo.addBuildTypeInfo;
import static com.redhat.red.build.koji.model.xmlrpc.KojiXmlRpcConstants.*;

import static com.redhat.red.build.koji.model.xmlrpc.messages.Constants.GET_BUILD;
import static com.redhat.red.build.koji.model.xmlrpc.messages.MultiCallRequest.getBuilder;
import static org.apache.commons.lang.StringUtils.isEmpty;
import static org.apache.commons.lang.StringUtils.isNotEmpty;
import static org.apache.http.client.utils.HttpClientUtils.closeQuietly;

/**
 * Created by jdcasey on 12/3/15.
 */
public class KojiClient
        implements Closeable
{
    static Logger logger = LoggerFactory.getLogger( KojiClient.class );

    private HC4SyncObjectClient xmlrpcClient;

    private HttpFactory httpFactory;

    private ExecutorService executorService;

    private MetricRegistry metricRegistry;

    private ExecutorCompletionService uploadService;

    private KojiObjectMapper objectMapper;

    private KojiConfig config;

    public KojiConfig getConfig()
    {
        return config;
    }

    private AtomicInteger callCount = new AtomicInteger( 0 );

    private static final RequestModifier STANDARD_REQUEST_MODIFIER = ( request ) -> {
        request.setHeader( ACCEPT_ENCODING_HEADER, IDENTITY_ENCODING_VALUE );
        logger.debug( "\n\n\n\nTarget URI: {}\n\n\n\n", request.getURI() );
    };

    private static final UrlBuilder NO_OP_URL_BUILDER = ( url ) -> new UrlBuildResult( url );

    private UrlBuilder sessionUrlBuilder( KojiSessionInfo session )
    {
        return sessionUrlBuilder( session, null );
    }

    private UrlBuilder sessionUrlBuilder( KojiSessionInfo session, Supplier> paramEditor )
    {
        return ( url ) -> {
            if ( session == null )
            {
                return new UrlBuildResult( url );
            }

            Map params = new HashMap<>();
            params.put( SESSION_ID_PARAM, Integer.toString( session.getSessionId() ) );
            params.put( SESSION_KEY_PARAM, session.getSessionKey() );
            params.put( CALL_NUMBER_PARAM, Integer.toString( callCount.getAndIncrement() ) );

            if ( paramEditor != null )
            {
                Map extraParams = paramEditor.get();
                if ( extraParams != null )
                {
                    MalformedURLException error = (MalformedURLException) extraParams.get( EMBEDDED_ERROR_PARAM );
                    if ( error != null )
                    {
                        return new UrlBuildResult( error );
                    }
                    else
                    {
                        extraParams.forEach( ( key, value ) -> {
                            params.put( key, String.valueOf( value ) );
                        } );
                    }
                }
            }

            String result = UrlUtils.buildUrl( url, params );

            logger.debug( "\n\n\n\nBuild URL: {}\n\n\n\n", result );
            return new UrlBuildResult( result );
        };
    }

    public KojiClient( KojiConfig config, PasswordManager passwordManager, ExecutorService executorService,
                       MetricRegistry metricRegistry ) throws KojiClientException
    {
        this.config = config;
        this.httpFactory = new HttpFactory( passwordManager );
        this.executorService = executorService;
        this.metricRegistry = metricRegistry;
        setup();
    }

    public KojiClient( KojiConfig config, PasswordManager passwordManager, ExecutorService executorService )
                    throws KojiClientException
    {
        this( config, passwordManager, executorService, null );
    }

    @Override
    public synchronized void close()
    {
        if ( xmlrpcClient != null )
        {
            xmlrpcClient.close();
            xmlrpcClient = null;
        }
    }

    static
    {
        Registry.setInstance( new Model_Registry() ); // Register RWX Parser/Renderers
    }

    public void setup()
                    throws KojiClientException
    {
        uploadService = new ExecutorCompletionService<>( executorService );
        objectMapper = new KojiObjectMapper();

        logger.debug( "SETUP: Starting KojiClient for: " + config.getKojiURL() );
        try
        {
            xmlrpcClient = new HC4SyncObjectClient( httpFactory, config.getKojiSiteConfig(), metricRegistry );
        }
        catch ( IOException e )
        {
            xmlrpcClient.close();
            xmlrpcClient = null;
            throw new KojiClientException("Cannot construct koji HTTP site-config: " + e.getMessage(), e);
        }

        try
        {
            ApiVersionResponse response =
                    xmlrpcClient.call( new ApiVersionRequest(), ApiVersionResponse.class, NO_OP_URL_BUILDER,
                                       STANDARD_REQUEST_MODIFIER );

            if ( 1 != response.getApiVersion() )
            {
                logger.error( "Cannot connect to koji at: " + config.getKojiURL() + ". API Version reported is '"
                                      + response.getApiVersion() + "' but this client only supports version 1." );
                xmlrpcClient.close();
                xmlrpcClient = null;
            }
        }
        catch ( XmlRpcException e )
        {
            logger.error(
                    "Cannot retrieve koji API version from: " + config.getKojiURL() + ". (Reason: " + e.getMessage()
                            + ")", e );
            xmlrpcClient.close();
            xmlrpcClient = null;
        }
    }

    public int getApiVersion()
            throws KojiClientException
    {
        checkConnection();

        try
        {
            ApiVersionResponse response =
                    xmlrpcClient.call( new ApiVersionRequest(), ApiVersionResponse.class, NO_OP_URL_BUILDER,
                                       STANDARD_REQUEST_MODIFIER );

            return response == null ? -1 : response.getApiVersion();
        }
        catch ( XmlRpcException e )
        {
            throw new KojiClientException( "Cannot retrieve koji API version from: %s. (Reason: %s)", e,
                                           config.getKojiURL(), e.getMessage() );
        }
    }

    public KojiSessionInfo krbLogin()
            throws KojiClientException
    {
        checkConnection();

        try
        {
            KrbAuthenticator krbAuthenticator = new KrbAuthenticator( config );

            String encodedApReq = krbAuthenticator.prepareRequest();

            KrbLoginResponse loginResponse =
                    xmlrpcClient.call( new KrbLoginRequest( encodedApReq ), KrbLoginResponse.class, NO_OP_URL_BUILDER, STANDARD_REQUEST_MODIFIER );

            if ( loginResponse == null )
            {
                throw new KojiClientException( "Failed to get loginResponse" );
            }

            KojiSessionInfo session = krbAuthenticator.hanldleResponse( loginResponse );
            setLoggedInUser( session );

            return session;
        }
        catch ( XmlRpcException e )
        {
            throw new KojiClientException( "Failed to login: %s", e, e.getMessage() );
        }
    }

    public KojiSessionInfo login()
            throws KojiClientException
    {
        checkConnection();

        if ( config.getKrbService() != null )
        {
            return krbLogin();
        }

        try
        {
            UrlBuilder urlBuilder = ( url ) -> new UrlBuildResult( UrlUtils.buildUrl( url, SSL_LOGIN_PATH ) );

            RequestModifier requestModifier =
                    ( request ) -> request.setHeader( ACCEPT_ENCODING_HEADER, IDENTITY_ENCODING_VALUE );

            LoginResponse loginResponse =
                    xmlrpcClient.call( new LoginRequest(), LoginResponse.class, urlBuilder, requestModifier );

            if ( loginResponse == null )
            {
                throw new KojiClientException( "Failed to get loginResponse" );
            }

            KojiSessionInfo session = loginResponse.getSessionInfo();
            setLoggedInUser( session );

            return session;
        }
        catch ( XmlRpcException e )
        {
            throw new KojiClientException( "Failed to login: %s", e, e.getMessage() );
        }
    }

    public  T withKojiSession( KojiCustomCommand command )
            throws KojiClientException
    {
        KojiSessionInfo session = null;
        T result = null;
        try
        {
            session = login();
            result = command.execute( session );
        }
        catch ( Exception e )
        {
            if ( logger.isDebugEnabled() )
            {
                logger.error( "Koji withSession lambda failed", e );
            }

            if ( e instanceof KojiClientException )
            {
                throw e;
            }
            else
            {
                throw new KojiClientException( "Koji withSession lambda command failed: %s", e, e.getMessage() );
            }
        }
        finally
        {
            logout( session );
        }

        return result;
    }

    private interface KojiInternalCommand
    {
        T execute()
                throws KojiClientException, XmlRpcException;
    }

    private  T doXmlRpcAndThrow( KojiInternalCommand cmd, String message, Object... params )
            throws KojiClientException
    {
        checkConnection();

        try
        {
            return cmd.execute();
        }
        catch ( XmlRpcException e )
        {
            throw new KojiClientException( "%s. Reason: %s", e, String.format( message, params ), e.getMessage() );
        }
    }

    @SuppressWarnings("unused")
    private  T doXmlRpcAndWarn( KojiInternalCommand cmd, String message, Object... params )
    {
        try
        {
            checkConnection();

            return cmd.execute();
        }
        catch ( XmlRpcException | KojiClientException e )
        {
            String formatted = String.format( "%s. Reason: %s", String.format( message, params ), e.getMessage() );
            if ( logger.isDebugEnabled() )
            {
                logger.warn( formatted, e );
            }
            else
            {
                logger.warn( formatted );
            }
        }

        return null;
    }

    public KojiUserInfo getLoggedInUserInfo( String username )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            UserResponse response =
                    xmlrpcClient.call( new UserRequest( username ), UserResponse.class, NO_OP_URL_BUILDER,
                                       STANDARD_REQUEST_MODIFIER );

            return response == null ? null : response.getUserInfo();
        }, "Failed to retrieve current user info." );
    }

    public KojiUserInfo getLoggedInUserInfo( KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            UserResponse response =
                    xmlrpcClient.call( new LoggedInUserRequest(), UserResponse.class, sessionUrlBuilder( session ),
                                       STANDARD_REQUEST_MODIFIER );
                return response == null ? null : response.getUserInfo();
        }, "Failed to retrieve current user info." );
    }

    public void logout( KojiSessionInfo session )
    {
        if ( session == null )
        {
            return;
        }

        if ( xmlrpcClient != null )
        {
            try
            {
                StatusResponse response =
                        xmlrpcClient.call( new LogoutRequest(), StatusResponse.class, sessionUrlBuilder( session ),
                                           STANDARD_REQUEST_MODIFIER );

                if ( isNotEmpty( response.getError() ) )
                {
                    logger.error( "Failed to logout from Koji: {}", response.getError() );
                }
            }
            catch ( XmlRpcException e )
            {
                logger.error( String.format( "Failed to logout: %s", e.getMessage() ), e );
            }
        }

        try
        {
            session.destroy();
        }
        catch ( DestroyFailedException e )
        {
            logger.error( String.format( "Failed to destroy session: %s", e.getMessage() ), e );
        }
    }

    private void checkConnection()
            throws KojiClientException
    {
        if ( xmlrpcClient == null )
        {
            throw new KojiClientException( "Connection to koji at %s is closed. Perhaps it failed to initialize?",
                                           config.getKojiURL() );
        }
    }

    public List getAllPermissions( KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            AllPermissionsResponse response =
                    xmlrpcClient.call( new AllPermissionsRequest(), AllPermissionsResponse.class,
                                       sessionUrlBuilder( session ), STANDARD_REQUEST_MODIFIER );

            return response == null ? null : response.getPermissions();
        }, "Failed to retrieve listing of koji permissions." );
    }

    public boolean hasPermission( String permission, KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            ConfirmationResponse response =
                    xmlrpcClient.call( new CheckPermissionRequest( permission ), ConfirmationResponse.class,
                                       sessionUrlBuilder( session ), STANDARD_REQUEST_MODIFIER );

            return response == null ? false : response.isSuccess();
        }, "Failed to check whether logged-in user has permission: %s", permission );
    }

    public Integer createTag( CreateTagRequest request, KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            IdResponse response = xmlrpcClient.call( request, IdResponse.class, sessionUrlBuilder( session ),
                                                     STANDARD_REQUEST_MODIFIER );

            return response == null ? null : response.getId();
        }, "Failed to create tag: %s", request );
    }

    public KojiTagInfo getTag( int tagId, KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            TagResponse response =
                    xmlrpcClient.call( new TagRequest( tagId ), TagResponse.class, sessionUrlBuilder( session ),
                                       STANDARD_REQUEST_MODIFIER );

            return response == null ? null : response.getTagInfo();
        }, "Failed to retrieve tag: %s", tagId );
    }

    public KojiTagInfo getTag( String tagName, KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            TagResponse response =
                    xmlrpcClient.call( new TagRequest( tagName ), TagResponse.class, sessionUrlBuilder( session ),
                                       STANDARD_REQUEST_MODIFIER );

            return response == null ? null : response.getTagInfo();
        }, "Failed to retrieve tag: %s", tagName );
    }

    public Integer getTagId( String tagName, KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            IdResponse response =
                    xmlrpcClient.call( new GetTagIdRequest( tagName ), IdResponse.class, sessionUrlBuilder( session ),
                                       STANDARD_REQUEST_MODIFIER );

            return response == null ? null : response.getId();
        }, "Failed to retrieve tag: %s", tagName );
    }

    public Integer getPackageId( String packageName, KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            IdResponse response = xmlrpcClient.call( new GetTagIdRequest( packageName ), IdResponse.class,
                                                     sessionUrlBuilder( session ), STANDARD_REQUEST_MODIFIER );

            return response == null ? null : response.getId();
        }, "Failed to retrieve package: %s", packageName );
    }

    public Map getArchiveTypeMap( KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( ()->{
            GetArchiveTypesResponse response =
                    xmlrpcClient.call( new GetArchiveTypesRequest(), GetArchiveTypesResponse.class,
                                       sessionUrlBuilder( session ), STANDARD_REQUEST_MODIFIER );

            if ( response == null )
            {
                return Collections.emptyMap();
            }

            Map types = new HashMap<>();
            response.getArchiveTypes()
                    .forEach( ( at ) -> at.getExtensions().forEach( ( ext ) -> types.put( ext, at ) ) );


            return types;
        }, "Failed to retrieve list of acceptable archive types" );
    }

    public KojiArchiveType getArchiveType( GetArchiveTypeRequest request, KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            GetArchiveTypeResponse response =
                    xmlrpcClient.call( request, GetArchiveTypeResponse.class,
                                       sessionUrlBuilder( session ), STANDARD_REQUEST_MODIFIER );

            return response == null ? null : response.getArchiveType();
        }, "Failed to retrieve archive type for request: %s", request );
    }

    public KojiImportResult importBuild( KojiImport importInfo, Iterable> importedFileSuppliers,
                                         KojiSessionInfo session )
            throws KojiClientException
    {
        return doXmlRpcAndThrow( () -> {
            try
            {
                String dirname = generateUploadDirname( session, importInfo );

                Map uploadErrors =
                        uploadForImport( null, importedFileSuppliers, dirname, session );

                if ( !uploadErrors.isEmpty() )
                {
                    return new KojiImportResult( importInfo ).withUploadErrors( uploadErrors );
                }

                GetBuildResponse response =
                        xmlrpcClient.call( new CGInlinedImportRequest( importInfo, dirname ), GetBuildResponse.class,
                                           sessionUrlBuilder( session ), STANDARD_REQUEST_MODIFIER );

                return new KojiImportResult( importInfo ).withBuildInfo( response.getBuildInfo() );
            }
            catch ( RuntimeException e )
            {
                logger.error( "FAIL: " + e.getMessage(), e );
                throw e;
            }
        }, "Failed to execute content-generator import" );
    }

    public  List queryCountOnly( String method, List queries, KojiSessionInfo session )
        throws KojiClientException
    {
        Registry registry = Registry.getInstance();

        List