source.dussan.org Git - archiva.git/blob

   1 package org.apache.maven.archiva.database;
   2
   3
   4 /*
   5  * Licensed to the Apache Software Foundation (ASF) under one
   6  * or more contributor license agreements.  See the NOTICE file
   7  * distributed with this work for additional information
   8  * regarding copyright ownership.  The ASF licenses this file
   9  * to you under the Apache License, Version 2.0 (the
  10  * "License"); you may not use this file except in compliance
  11  * with the License.  You may obtain a copy of the License at
  12  *
  13  *  http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing,
  16  * software distributed under the License is distributed on an
  17  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  18  * KIND, either express or implied.  See the License for the
  19  * specific language governing permissions and limitations
  20  * under the License.
  21  */
  22
  23 import com.ibatis.sqlmap.client.SqlMapClient;
  24
  25 import org.apache.maven.archiva.database.key.MetadataKey;
  26 import org.apache.maven.artifact.repository.metadata.Metadata;
  27 import org.codehaus.plexus.ibatis.PlexusIbatisHelper;
  28 import org.codehaus.plexus.logging.AbstractLogEnabled;
  29 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  30 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  31
  32 import java.sql.Connection;
  33 import java.sql.DatabaseMetaData;
  34 import java.sql.ResultSet;
  35 import java.sql.SQLException;
  36
  37
  38 /**
  39  *
  40  * IbatisMetadataStore
  41  *
  42  * @author <a href="mailto:jmcconnell@apache.com">Jesse McConnell</a>
  43  * @version $Id$
  44  *
  45  */
  46 public class AbstractMetadataKeyDatabase
  47     extends AbstractLogEnabled
  48     implements Initializable
  49 {
  50     /**
  51      * @plexus.requirement
  52      */
  53     protected PlexusIbatisHelper ibatisHelper;
  54
  55     /**
  56      * @plexus.configuration default-value="create"
  57      */
  58     private String createPrefix;
  59
  60     /**
  61      * @plexus.configuration default-value="drop"
  62      */
  63     private String dropPrefix;
  64
  65     public MetadataKey getMetadataKey( Metadata metadata )
  66         throws ArchivaDatabaseException
  67     {
  68         SqlMapClient sqlMap = ibatisHelper.getSqlMapClient();
  69
  70         try
  71         {
  72             sqlMap.startTransaction();
  73
  74             getLogger().info( "Getting metadata key" );
  75             MetadataKey newMetadataKey = (MetadataKey) sqlMap.queryForObject( "getMetadataKey", metadata );
  76
  77             if ( newMetadataKey == null )
  78             {
  79                 getLogger().info( "added new metadata" );
  80                 sqlMap.update( "addMetadataKey", metadata );
  81
  82                 newMetadataKey = (MetadataKey) sqlMap.queryForObject( "getMetadataKey", metadata );
  83
  84                 if ( newMetadataKey == null )
  85                 {
  86                     throw new ArchivaDatabaseException( "unable to create new MetadataKeys" );
  87                 }
  88             }
  89
  90             return newMetadataKey;
  91
  92         }
  93         catch ( SQLException e )
  94         {
  95             getLogger().error( "Error while adding metadata, showing all linked exceptions in SQLException." );
  96
  97             while ( e != null )
  98             {
  99                 getLogger().error( e.getMessage(), e );
 100
 101                 e = e.getNextException();
 102             }
 103
 104             throw new ArchivaDatabaseException ( "Error while interacting with the database.", e );
 105         }
 106         finally
 107         {
 108             try
 109             {
 110                 sqlMap.endTransaction();
 111             }
 112             catch ( SQLException e )
 113             {
 114                 e.printStackTrace();
 115             }
 116         }
 117     }
 118
 119
 120     protected void initializeTable( String tableName )
 121         throws ArchivaDatabaseException
 122     {
 123         SqlMapClient sqlMap = ibatisHelper.getSqlMapClient();
 124
 125         try
 126         {
 127             sqlMap.startTransaction();
 128
 129             Connection con = sqlMap.getCurrentConnection();
 130
 131             DatabaseMetaData databaseMetaData = con.getMetaData();
 132
 133             ResultSet rs = databaseMetaData.getTables( con.getCatalog(), null, null, null );
 134
 135             // check if the index database exists in the database
 136             while ( rs.next() )
 137             {
 138                 String dbTableName = rs.getString( "TABLE_NAME" );
 139
 140                 // if it does then we are already initialized
 141                 if ( dbTableName.toLowerCase().equals( tableName.toLowerCase() ) )
 142                 {
 143                     return;
 144                 }
 145             }
 146
 147             // Create the tables
 148
 149             getLogger().info( "Creating table: " + tableName );
 150             sqlMap.update( createPrefix + tableName, null );
 151
 152             sqlMap.commitTransaction();
 153         }
 154         catch ( SQLException e )
 155         {
 156             getLogger().error( "Error while initializing database, showing all linked exceptions in SQLException." );
 157
 158             while ( e != null )
 159             {
 160                 getLogger().error( e.getMessage(), e );
 161
 162                 e = e.getNextException();
 163             }
 164
 165             throw new ArchivaDatabaseException( "Error while setting up database.", e );
 166         }
 167         finally
 168         {
 169             try
 170             {
 171                 sqlMap.endTransaction();
 172             }
 173             catch ( SQLException e )
 174             {
 175                 e.printStackTrace();
 176             }
 177         }
 178     }
 179
 180     protected void dropTable( String tableName )
 181     throws ArchivaDatabaseException
 182     {
 183     SqlMapClient sqlMap = ibatisHelper.getSqlMapClient();
 184
 185     try
 186     {
 187         sqlMap.startTransaction();
 188
 189         getLogger().info( "Dropping table: " + tableName );
 190         sqlMap.update( dropPrefix + tableName, null );
 191
 192         sqlMap.commitTransaction();
 193     }
 194     catch ( SQLException e )
 195     {
 196         getLogger().error( "Error while dropping database, showing all linked exceptions in SQLException." );
 197
 198         while ( e != null )
 199         {
 200             getLogger().error( e.getMessage(), e );
 201
 202             e = e.getNextException();
 203         }
 204
 205         throw new ArchivaDatabaseException( "Error while dropping database.", e );
 206     }
 207     finally
 208     {
 209         try
 210         {
 211             sqlMap.endTransaction();
 212         }
 213         catch ( SQLException e )
 214         {
 215             e.printStackTrace();
 216         }
 217     }
 218 }
 219
 220     public void initialize()
 221         throws InitializationException
 222     {
 223         try
 224         {
 225             initializeTable( "MetadataKeys" );
 226         }
 227         catch ( ArchivaDatabaseException ade )
 228         {
 229             throw new InitializationException( "unable to initialize metadata keys database" );
 230         }
 231     }
 232
 233
 234     protected boolean tableExists( String tableName )
 235     throws ArchivaDatabaseException
 236 {
 237     SqlMapClient sqlMap = ibatisHelper.getSqlMapClient();
 238
 239     try
 240     {
 241         sqlMap.startTransaction();
 242
 243         Connection con = sqlMap.getCurrentConnection();
 244
 245         DatabaseMetaData databaseMetaData = con.getMetaData();
 246
 247         ResultSet rs = databaseMetaData.getTables( con.getCatalog(), null, null, null );
 248
 249         // check if the index database exists in the database
 250         while ( rs.next() )
 251         {
 252             String dbTableName = rs.getString( "TABLE_NAME" );
 253
 254             // if it does then we are already initialized
 255             if ( dbTableName.toLowerCase().equals( tableName.toLowerCase() ) )
 256             {
 257                 return true;
 258             }
 259         }
 260         return false;
 261     }
 262     catch ( SQLException e )
 263     {
 264         getLogger().error( "Error while check database, showing all linked exceptions in SQLException." );
 265
 266         while ( e != null )
 267         {
 268             getLogger().error( e.getMessage(), e );
 269
 270             e = e.getNextException();
 271         }
 272
 273         throw new ArchivaDatabaseException( "Error while checking database.", e );
 274     }
 275     finally
 276     {
 277         try
 278         {
 279             sqlMap.endTransaction();
 280         }
 281         catch ( SQLException e )
 282         {
 283             e.printStackTrace();
 284         }
 285     }
 286 }
 287
 288 }