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

   1 package org.apache.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 @Service( "mimeTpes" )
  47 public class MimeTypes
  48 {
  49     private static final String DEFAULT_MIME_TYPE = "application/octet-stream";
  50
  51     private String resource = "org/apache/archiva/webdav/util/mime.types";
  52
  53     private Map<String, String> mimeMap = new HashMap<String, String>();
  54
  55     private Logger log = LoggerFactory.getLogger( MimeTypes.class );
  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         if ( value == null )
  77         {
  78             value = DEFAULT_MIME_TYPE;
  79         }
  80
  81         return value;
  82
  83     }
  84
  85     @PostConstruct
  86     public void initialize()
  87     {
  88         load( resource );
  89     }
  90
  91     public void load( File file )
  92     {
  93         if ( !file.exists() || !file.isFile() || !file.canRead() )
  94         {
  95             log.error( "Unable to load mime types from file " + file.getAbsolutePath() + " : not a readable file." );
  96             return;
  97         }
  98
  99         FileInputStream fis = null;
 100
 101         try
 102         {
 103             fis = new FileInputStream( file );
 104         }
 105         catch ( FileNotFoundException e )
 106         {
 107             log.error( "Unable to load mime types from file " + file.getAbsolutePath() + " : " + e.getMessage(), e );
 108         }
 109         finally
 110         {
 111             IOUtils.closeQuietly( fis );
 112         }
 113     }
 114
 115     public void load( String resourceName )
 116     {
 117         ClassLoader cloader = this.getClass().getClassLoader();
 118
 119         /* Load up the mime types table */
 120         URL mimeURL = cloader.getResource( resourceName );
 121
 122         if ( mimeURL == null )
 123         {
 124             throw new IllegalStateException( "Unable to find resource " + resourceName );
 125         }
 126
 127         InputStream mimeStream = null;
 128
 129         try
 130         {
 131             mimeStream = mimeURL.openStream();
 132             load( mimeStream );
 133         }
 134         catch ( IOException e )
 135         {
 136             log.error( "Unable to load mime map " + resourceName + " : " + e.getMessage(), e );
 137         }
 138         finally
 139         {
 140             IOUtils.closeQuietly( mimeStream );
 141         }
 142     }
 143
 144     public void load( InputStream mimeStream )
 145     {
 146         mimeMap.clear();
 147
 148         InputStreamReader reader = null;
 149         BufferedReader buf = null;
 150
 151         try
 152         {
 153             reader = new InputStreamReader( mimeStream );
 154             buf = new BufferedReader( reader );
 155             String line = null;
 156
 157             while ( ( line = buf.readLine() ) != null )
 158             {
 159                 line = line.trim();
 160
 161                 if ( line.length() == 0 )
 162                 {
 163                     // empty line. skip it
 164                     continue;
 165                 }
 166
 167                 if ( line.startsWith( "#" ) )
 168                 {
 169                     // Comment. skip it
 170                     continue;
 171                 }
 172
 173                 StringTokenizer tokenizer = new StringTokenizer( line );
 174                 if ( tokenizer.countTokens() > 1 )
 175                 {
 176                     String type = tokenizer.nextToken();
 177                     while ( tokenizer.hasMoreTokens() )
 178                     {
 179                         String extension = tokenizer.nextToken().toLowerCase();
 180                         this.mimeMap.put( extension, type );
 181                     }
 182                 }
 183             }
 184         }
 185         catch ( IOException e )
 186         {
 187             log.error( "Unable to read mime types from input stream : " + e.getMessage(), e );
 188         }
 189         finally
 190         {
 191             IOUtils.closeQuietly( buf );
 192             IOUtils.closeQuietly( reader );
 193         }
 194     }
 195
 196     public String getResource()
 197     {
 198         return resource;
 199     }
 200
 201     public void setResource( String resource )
 202     {
 203         this.resource = resource;
 204     }
 205 }