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

   1 package org.apache.maven.archiva.webdav.util;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.commons.io.IOUtils;
  23 import org.apache.commons.lang.StringUtils;
  24 import org.codehaus.plexus.logging.AbstractLogEnabled;
  25 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  26 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  27
  28 import java.io.BufferedReader;
  29 import java.io.File;
  30 import java.io.FileInputStream;
  31 import java.io.FileNotFoundException;
  32 import java.io.IOException;
  33 import java.io.InputStream;
  34 import java.io.InputStreamReader;
  35 import java.net.URL;
  36 import java.util.HashMap;
  37 import java.util.Map;
  38 import java.util.StringTokenizer;
  39
  40 /**
  41  * MimeTypes
  42  *
  43  * @version $Id: MimeTypes.java 7010 2007-10-25 23:35:02Z joakime $
  44  *
  45  * @plexus.component role="org.apache.maven.archiva.webdav.util.MimeTypes"
  46  */
  47 public class MimeTypes
  48     extends AbstractLogEnabled
  49     implements Initializable
  50 {
  51     private static final String DEFAULT_MIME_TYPE = "application/octet-stream";
  52
  53     private String resource = "org/apache/maven/archiva/webdav/util/mime.types";
  54
  55     private Map mimeMap = new HashMap();
  56
  57     /**
  58      * Get the Mime Type for the provided filename.
  59      *
  60      * @param filename the filename to obtain the mime type for.
  61      * @return a mime type String, or null if filename is null, has no extension, or no mime type is associated with it.
  62      */
  63     public String getMimeType( String filename )
  64     {
  65         String value = null;
  66         if ( !StringUtils.isEmpty( filename ) )
  67         {
  68             int index = filename.lastIndexOf( '.' );
  69
  70             if ( index >= 0 )
  71             {
  72                 value = (String) mimeMap.get( filename.substring( index + 1 ).toLowerCase() );
  73             }
  74         }
  75
  76
  77         if (value == null)
  78         {
  79             value = DEFAULT_MIME_TYPE;
  80         }
  81
  82         return value;
  83
  84     }
  85
  86     public void initialize()
  87         throws InitializationException
  88     {
  89         load( resource );
  90     }
  91
  92     public void load( File file )
  93     {
  94         if ( !file.exists() || !file.isFile() || !file.canRead() )
  95         {
  96             getLogger().error( "Unable to load mime types from file " + file.getAbsolutePath() + " : not a readable file." );
  97             return;
  98         }
  99
 100         FileInputStream fis = null;
 101
 102         try
 103         {
 104             fis = new FileInputStream( file );
 105         }
 106         catch ( FileNotFoundException e )
 107         {
 108             getLogger().error( "Unable to load mime types from file " + file.getAbsolutePath() + " : " + e.getMessage(), e );
 109         }
 110         finally
 111         {
 112             IOUtils.closeQuietly( fis );
 113         }
 114     }
 115
 116     public void load( String resourceName )
 117     {
 118         ClassLoader cloader = this.getClass().getClassLoader();
 119
 120         /* Load up the mime types table */
 121         URL mimeURL = cloader.getResource( resourceName );
 122
 123         if ( mimeURL == null )
 124         {
 125             throw new IllegalStateException( "Unable to find resource " + resourceName );
 126         }
 127
 128         InputStream mimeStream = null;
 129
 130         try
 131         {
 132             mimeStream = mimeURL.openStream();
 133             load( mimeStream );
 134         }
 135         catch ( IOException e )
 136         {
 137             getLogger().error( "Unable to load mime map " + resourceName + " : " + e.getMessage(), e );
 138         }
 139         finally
 140         {
 141             IOUtils.closeQuietly( mimeStream );
 142         }
 143     }
 144
 145     public void load( InputStream mimeStream )
 146     {
 147         mimeMap.clear();
 148
 149         InputStreamReader reader = null;
 150         BufferedReader buf = null;
 151
 152         try
 153         {
 154             reader = new InputStreamReader( mimeStream );
 155             buf = new BufferedReader( reader );
 156             String line = null;
 157
 158             while ( ( line = buf.readLine() ) != null )
 159             {
 160                 line = line.trim();
 161
 162                 if ( line.length() == 0 )
 163                 {
 164                     // empty line. skip it
 165                     continue;
 166                 }
 167
 168                 if ( line.startsWith( "#" ) )
 169                 {
 170                     // Comment. skip it
 171                     continue;
 172                 }
 173
 174                 StringTokenizer tokenizer = new StringTokenizer( line );
 175                 if ( tokenizer.countTokens() > 1 )
 176                 {
 177                     String type = tokenizer.nextToken();
 178                     while ( tokenizer.hasMoreTokens() )
 179                     {
 180                         String extension = tokenizer.nextToken().toLowerCase();
 181                         this.mimeMap.put( extension, type );
 182                     }
 183                 }
 184             }
 185         }
 186         catch ( IOException e )
 187         {
 188             getLogger().error( "Unable to read mime types from input stream : " + e.getMessage(), e );
 189         }
 190         finally
 191         {
 192             IOUtils.closeQuietly( buf );
 193             IOUtils.closeQuietly( reader );
 194         }
 195     }
 196 }