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

   1 package org.apache.archiva.web.action;
   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 com.opensymphony.xwork2.ActionContext;
  23 import com.opensymphony.xwork2.ActionSupport;
  24 import org.apache.archiva.admin.model.AuditInformation;
  25 import org.apache.archiva.audit.AuditEvent;
  26 import org.apache.archiva.audit.AuditListener;
  27 import org.apache.archiva.audit.Auditable;
  28 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  29 import org.apache.archiva.security.ArchivaXworkUser;
  30 import org.apache.commons.lang.StringUtils;
  31 import org.apache.struts2.ServletActionContext;
  32 import org.apache.struts2.interceptor.SessionAware;
  33 import org.codehaus.plexus.redback.users.User;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36 import org.springframework.context.ApplicationContext;
  37
  38 import javax.annotation.PostConstruct;
  39 import javax.inject.Inject;
  40 import javax.inject.Named;
  41 import javax.servlet.http.HttpServletRequest;
  42 import java.util.ArrayList;
  43 import java.util.Date;
  44 import java.util.HashMap;
  45 import java.util.List;
  46 import java.util.Map;
  47
  48 /**
  49  * LogEnabled and SessionAware ActionSupport
  50  */
  51 public abstract class AbstractActionSupport
  52     extends ActionSupport
  53     implements SessionAware, Auditable
  54 {
  55     protected Map<?, ?> session;
  56
  57     protected Logger log = LoggerFactory.getLogger( getClass() );
  58
  59     @Inject
  60     private List<AuditListener> auditListeners = new ArrayList<AuditListener>();
  61
  62
  63     @Inject
  64     @Named( value = "repositorySessionFactory" )
  65     protected RepositorySessionFactory repositorySessionFactory;
  66
  67     @Inject
  68     protected ApplicationContext applicationContext;
  69
  70     private String principal;
  71
  72     @PostConstruct
  73     public void initialize()
  74     {
  75         // no op
  76     }
  77
  78     @SuppressWarnings( "unchecked" )
  79     public void setSession( Map map )
  80     {
  81         this.session = map;
  82     }
  83
  84     public void addAuditListener( AuditListener listener )
  85     {
  86         this.auditListeners.add( listener );
  87     }
  88
  89     public void clearAuditListeners()
  90     {
  91         this.auditListeners.clear();
  92     }
  93
  94     public void removeAuditListener( AuditListener listener )
  95     {
  96         this.auditListeners.remove( listener );
  97     }
  98
  99     protected void triggerAuditEvent( String repositoryId, String resource, String action )
 100     {
 101         AuditEvent event = new AuditEvent( repositoryId, getPrincipal(), resource, action );
 102         event.setRemoteIP( getRemoteAddr() );
 103
 104         for ( AuditListener listener : auditListeners )
 105         {
 106             listener.auditEvent( event );
 107         }
 108     }
 109
 110     protected void triggerAuditEvent( String resource, String action )
 111     {
 112         AuditEvent event = new AuditEvent( null, getPrincipal(), resource, action );
 113         event.setRemoteIP( getRemoteAddr() );
 114
 115         for ( AuditListener listener : auditListeners )
 116         {
 117             listener.auditEvent( event );
 118         }
 119     }
 120
 121     protected void triggerAuditEvent( String action )
 122     {
 123         AuditEvent event = new AuditEvent( null, getPrincipal(), null, action );
 124         event.setRemoteIP( getRemoteAddr() );
 125
 126         for ( AuditListener listener : auditListeners )
 127         {
 128             listener.auditEvent( event );
 129         }
 130     }
 131
 132     private String getRemoteAddr()
 133     {
 134         HttpServletRequest request = ServletActionContext.getRequest();
 135         return request != null ? request.getRemoteAddr() : null;
 136     }
 137
 138     @SuppressWarnings( "unchecked" )
 139     protected String getPrincipal()
 140     {
 141         if ( principal != null )
 142         {
 143             return principal;
 144         }
 145         return ArchivaXworkUser.getActivePrincipal( ActionContext.getContext().getSession() );
 146     }
 147
 148     void setPrincipal( String principal )
 149     {
 150         this.principal = principal;
 151     }
 152
 153     public void setAuditListeners( List<AuditListener> auditListeners )
 154     {
 155         this.auditListeners = auditListeners;
 156     }
 157
 158     public void setRepositorySessionFactory( RepositorySessionFactory repositorySessionFactory )
 159     {
 160         this.repositorySessionFactory = repositorySessionFactory;
 161     }
 162
 163     protected <T> Map<String, T> getBeansOfType( Class<T> clazz )
 164     {
 165         //TODO do some caching here !!!
 166         // olamy : with plexus we get only roleHint
 167         // as per convention we named spring bean role#hint remove role# if exists
 168         Map<String, T> springBeans = applicationContext.getBeansOfType( clazz );
 169
 170         Map<String, T> beans = new HashMap<String, T>( springBeans.size() );
 171
 172         for ( Map.Entry<String, T> entry : springBeans.entrySet() )
 173         {
 174             String key = StringUtils.substringAfterLast( entry.getKey(), "#" );
 175             beans.put( key, entry.getValue() );
 176         }
 177         return beans;
 178     }
 179
 180
 181     protected AuditInformation getAuditInformation()
 182     {
 183         AuditInformation auditInformation = new AuditInformation( new SimpleUser( getPrincipal() ), getRemoteAddr() );
 184
 185         return auditInformation;
 186     }
 187
 188     /**
 189      * dummy information for audit events
 190      * @since 1.4
 191      */
 192     private static class SimpleUser
 193         implements User
 194     {
 195
 196         private String principal;
 197
 198         protected SimpleUser( String principal )
 199         {
 200             this.principal = principal;
 201         }
 202
 203         public Object getPrincipal()
 204         {
 205             return this.principal;
 206         }
 207
 208         public String getUsername()
 209         {
 210             return null;
 211         }
 212
 213         public void setUsername( String name )
 214         {
 215
 216         }
 217
 218         public String getFullName()
 219         {
 220             return null;
 221         }
 222
 223         public void setFullName( String name )
 224         {
 225
 226         }
 227
 228         public String getEmail()
 229         {
 230             return null;
 231         }
 232
 233         public void setEmail( String address )
 234         {
 235
 236         }
 237
 238         public String getPassword()
 239         {
 240             return null;
 241         }
 242
 243         public void setPassword( String rawPassword )
 244         {
 245
 246         }
 247
 248         public String getEncodedPassword()
 249         {
 250             return null;
 251         }
 252
 253         public void setEncodedPassword( String encodedPassword )
 254         {
 255
 256         }
 257
 258         public Date getLastPasswordChange()
 259         {
 260             return null;
 261         }
 262
 263         public void setLastPasswordChange( Date passwordChangeDate )
 264         {
 265
 266         }
 267
 268         public List<String> getPreviousEncodedPasswords()
 269         {
 270             return null;
 271         }
 272
 273         public void setPreviousEncodedPasswords( List<String> encodedPasswordList )
 274         {
 275
 276         }
 277
 278         public void addPreviousEncodedPassword( String encodedPassword )
 279         {
 280
 281         }
 282
 283         public boolean isPermanent()
 284         {
 285             return false;
 286         }
 287
 288         public void setPermanent( boolean permanent )
 289         {
 290
 291         }
 292
 293         public boolean isLocked()
 294         {
 295             return false;
 296         }
 297
 298         public void setLocked( boolean locked )
 299         {
 300
 301         }
 302
 303         public boolean isPasswordChangeRequired()
 304         {
 305             return false;
 306         }
 307
 308         public void setPasswordChangeRequired( boolean changeRequired )
 309         {
 310
 311         }
 312
 313         public boolean isValidated()
 314         {
 315             return false;
 316         }
 317
 318         public void setValidated( boolean valid )
 319         {
 320
 321         }
 322
 323         public int getCountFailedLoginAttempts()
 324         {
 325             return 0;
 326         }
 327
 328         public void setCountFailedLoginAttempts( int count )
 329         {
 330
 331         }
 332
 333         public Date getAccountCreationDate()
 334         {
 335             return null;
 336         }
 337
 338         public void setAccountCreationDate( Date date )
 339         {
 340
 341         }
 342
 343         public Date getLastLoginDate()
 344         {
 345             return null;
 346         }
 347
 348         public void setLastLoginDate( Date date )
 349         {
 350
 351         }
 352     }
 353
 354
 355 }