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

   1 package org.apache.archiva.rest.services;
   2 /*
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  *   http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import org.apache.archiva.rest.api.model.ArchivaRuntimeInfo;
  22 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  23 import org.apache.archiva.rest.api.services.CommonServices;
  24 import org.apache.commons.io.IOUtils;
  25 import org.apache.commons.lang.StringUtils;
  26 import org.codehaus.redback.components.scheduler.CronExpressionValidator;
  27 import org.codehaus.redback.rest.api.services.RedbackServiceException;
  28 import org.codehaus.redback.rest.api.services.UtilServices;
  29 import org.slf4j.Logger;
  30 import org.slf4j.LoggerFactory;
  31 import org.springframework.stereotype.Service;
  32
  33 import javax.inject.Inject;
  34 import javax.ws.rs.QueryParam;
  35 import javax.ws.rs.core.Response;
  36 import java.io.ByteArrayInputStream;
  37 import java.io.IOException;
  38 import java.io.InputStream;
  39 import java.util.Map;
  40 import java.util.Properties;
  41
  42 /**
  43  * @author Olivier Lamy
  44  */
  45 @Service( "commonServices#rest" )
  46 public class DefaultCommonServices
  47     implements CommonServices
  48 {
  49
  50     private static final String RESOURCE_NAME = "org/apache/archiva/i18n/default";
  51
  52     private Logger log = LoggerFactory.getLogger( getClass() );
  53
  54     @Inject
  55     private UtilServices utilServices;
  56
  57     @Inject
  58     protected CronExpressionValidator cronExpressionValidator;
  59
  60     public String getI18nResources( String locale )
  61         throws ArchivaRestServiceException
  62     {
  63         Properties properties = new Properties();
  64
  65         StringBuilder resourceName = new StringBuilder( RESOURCE_NAME );
  66         try
  67         {
  68
  69             loadResource( properties, resourceName, locale );
  70
  71         }
  72         catch ( IOException e )
  73         {
  74             log.warn( "skip error loading properties {}", resourceName.toString() );
  75         }
  76
  77         return fromProperties( properties );
  78     }
  79
  80     private void loadResource( Properties properties, StringBuilder resourceName, String locale )
  81         throws IOException
  82     {
  83         // load default
  84         loadResource( properties, new StringBuilder( resourceName ).append( ".properties" ).toString(), locale );
  85         // if locale override with locale content
  86         if ( StringUtils.isNotEmpty( locale ) )
  87         {
  88             loadResource( properties,
  89                           new StringBuilder( resourceName ).append( "_" + locale ).append( ".properties" ).toString(),
  90                           locale );
  91         }
  92
  93     }
  94
  95     private String fromProperties( final Properties properties )
  96     {
  97         StringBuilder output = new StringBuilder();
  98
  99         for ( Map.Entry<Object, Object> entry : properties.entrySet() )
 100         {
 101             output.append( (String) entry.getKey() ).append( '=' ).append( (String) entry.getValue() );
 102             output.append( '\n' );
 103         }
 104
 105         return output.toString();
 106     }
 107
 108     private void loadResource( final Properties finalProperties, String resourceName, String locale )
 109         throws IOException
 110     {
 111         InputStream is = null;
 112         Properties properties = new Properties();
 113         try
 114         {
 115             is = Thread.currentThread().getContextClassLoader().getResourceAsStream( resourceName.toString() );
 116             if ( is != null )
 117             {
 118                 properties.load( is );
 119                 finalProperties.putAll( properties );
 120             }
 121             else
 122             {
 123                 if ( !StringUtils.equalsIgnoreCase( locale, "en" ) )
 124                 {
 125                     log.info( "cannot load resource {}", resourceName );
 126                 }
 127             }
 128         }
 129         finally
 130         {
 131             IOUtils.closeQuietly( is );
 132         }
 133     }
 134
 135     public String getAllI18nResources( String locale )
 136         throws ArchivaRestServiceException
 137     {
 138         try
 139         {
 140
 141             Properties all = utilServices.getI18nProperties( locale );
 142             StringBuilder resourceName = new StringBuilder( RESOURCE_NAME );
 143             loadResource( all, resourceName, locale );
 144
 145             return fromProperties( all );
 146         }
 147         catch ( IOException e )
 148         {
 149             throw new ArchivaRestServiceException( e.getMessage(),
 150                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode() );
 151         }
 152         catch ( RedbackServiceException e )
 153         {
 154             throw new ArchivaRestServiceException( e.getMessage(), e.getHttpErrorCode() );
 155         }
 156     }
 157
 158     private void loadFromString( String propsStr, Properties properties )
 159         throws ArchivaRestServiceException
 160     {
 161         InputStream inputStream = null;
 162         try
 163         {
 164             inputStream = new ByteArrayInputStream( propsStr.getBytes() );
 165             properties.load( inputStream );
 166         }
 167         catch ( IOException e )
 168         {
 169             throw new ArchivaRestServiceException( e.getMessage(),
 170                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode() );
 171         }
 172         finally
 173         {
 174             IOUtils.closeQuietly( inputStream );
 175         }
 176     }
 177
 178     public ArchivaRuntimeInfo archivaRuntimeInfo()
 179     {
 180         return new ArchivaRuntimeInfo();
 181     }
 182
 183     public Boolean validateCronExpression( @QueryParam( "cronExpression" ) String cronExpression )
 184         throws ArchivaRestServiceException
 185     {
 186         return cronExpressionValidator.validate( cronExpression );
 187     }
 188 }