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.slf4j.Logger;
  25 import org.slf4j.LoggerFactory;
  26 import org.springframework.stereotype.Service;
  27
  28 import javax.annotation.PostConstruct;
  29 import java.io.BufferedReader;
  30 import java.io.File;
  31 import java.io.FileInputStream;
  32 import java.io.FileNotFoundException;
  33 import java.io.IOException;
  34 import java.io.InputStream;
  35 import java.io.InputStreamReader;
  36 import java.net.URL;
  37 import java.util.HashMap;
  38 import java.util.Map;
  39 import java.util.StringTokenizer;
  40
  41 /**
  42  * MimeTypes
  43  *
  44  * @version $Id: MimeTypes.java 7010 2007-10-25 23:35:02Z joakime $
  45  *
  46  * plexus.component role="org.apache.maven.archiva.webdav.util.MimeTypes"
  47  */
  48 @Service("mimeTpes")
  49 public class MimeTypes
  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<String, String> mimeMap = new HashMap<String, String>();
  56
  57     private Logger log = LoggerFactory.getLogger( MimeTypes.class );
  58
  59     /**
  60      * Get the Mime Type for the provided filename.
  61      *
  62      * @param filename the filename to obtain the mime type for.
  63      * @return a mime type String, or null if filename is null, has no extension, or no mime type is associated with it.
  64      */
  65     public String getMimeType( String filename )
  66     {
  67         String value = null;
  68         if ( !StringUtils.isEmpty( filename ) )
  69         {
  70             int index = filename.lastIndexOf( '.' );
  71
  72             if ( index >= 0 )
  73             {
  74                 value = (String) mimeMap.get( filename.substring( index + 1 ).toLowerCase() );
  75             }
  76         }
  77
  78
  79         if (value == null)
  80         {
  81             value = DEFAULT_MIME_TYPE;
  82         }
  83
  84         return value;
  85
  86     }
  87
  88     @PostConstruct
  89     public void initialize()
  90     {
  91         load( resource );
  92     }
  93
  94     public void load( File file )
  95     {
  96         if ( !file.exists() || !file.isFile() || !file.canRead() )
  97         {
  98             log.error( "Unable to load mime types from file " + file.getAbsolutePath() + " : not a readable file." );
  99             return;
 100         }
 101
 102         FileInputStream fis = null;
 103
 104         try
 105         {
 106             fis = new FileInputStream( file );
 107         }
 108         catch ( FileNotFoundException e )
 109         {
 110             log.error( "Unable to load mime types from file " + file.getAbsolutePath() + " : " + e.getMessage(), e );
 111         }
 112         finally
 113         {
 114             IOUtils.closeQuietly( fis );
 115         }
 116     }
 117
 118     public void load( String resourceName )
 119     {
 120         ClassLoader cloader = this.getClass().getClassLoader();
 121
 122         /* Load up the mime types table */
 123         URL mimeURL = cloader.getResource( resourceName );
 124
 125         if ( mimeURL == null )
 126         {
 127             throw new IllegalStateException( "Unable to find resource " + resourceName );
 128         }
 129
 130         InputStream mimeStream = null;
 131
 132         try
 133         {
 134             mimeStream = mimeURL.openStream();
 135             load( mimeStream );
 136         }
 137         catch ( IOException e )
 138         {
 139             log.error( "Unable to load mime map " + resourceName + " : " + e.getMessage(), e );
 140         }
 141         finally
 142         {
 143             IOUtils.closeQuietly( mimeStream );
 144         }
 145     }
 146
 147     public void load( InputStream mimeStream )
 148     {
 149         mimeMap.clear();
 150
 151         InputStreamReader reader = null;
 152         BufferedReader buf = null;
 153
 154         try
 155         {
 156             reader = new InputStreamReader( mimeStream );
 157             buf = new BufferedReader( reader );
 158             String line = null;
 159
 160             while ( ( line = buf.readLine() ) != null )
 161             {
 162                 line = line.trim();
 163
 164                 if ( line.length() == 0 )
 165                 {
 166                     // empty line. skip it
 167                     continue;
 168                 }
 169
 170                 if ( line.startsWith( "#" ) )
 171                 {
 172                     // Comment. skip it
 173                     continue;
 174                 }
 175
 176                 StringTokenizer tokenizer = new StringTokenizer( line );
 177                 if ( tokenizer.countTokens() > 1 )
 178                 {
 179                     String type = tokenizer.nextToken();
 180                     while ( tokenizer.hasMoreTokens() )
 181                     {
 182                         String extension = tokenizer.nextToken().toLowerCase();
 183                         this.mimeMap.put( extension, type );
 184                     }
 185                 }
 186             }
 187         }
 188         catch ( IOException e )
 189         {
 190             log.error( "Unable to read mime types from input stream : " + e.getMessage(), e );
 191         }
 192         finally
 193         {
 194             IOUtils.closeQuietly( buf );
 195             IOUtils.closeQuietly( reader );
 196         }
 197     }
 198
 199     public String getResource()
 200     {
 201         return resource;
 202     }
 203
 204     public void setResource( String resource )
 205     {
 206         this.resource = resource;
 207     }
 208 }