Changeset 902

Show
Ignore:
Timestamp:
10/16/06 20:54:17 (2 years ago)
Author:
alban
Message:

[Bug 149] add user configuration support to ConfigurationLoader?, made ReceiverConfiguration? storable into Configuration

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/source/org/kolaka/freecast/Application.java

    r893 r902  
    3636import org.apache.commons.cli.Options; 
    3737import org.apache.commons.cli.ParseException; 
     38import org.apache.commons.configuration.Configuration; 
     39import org.apache.commons.configuration.ConfigurationException; 
    3840import org.apache.commons.configuration.HierarchicalConfiguration; 
    3941import org.apache.commons.lang.StringUtils; 
    …… 
    6567        private HierarchicalConfiguration configuration; 
    6668 
     69  private ConfigurationLoader configurationLoader; 
     70 
    6771        protected Application(String name) { 
    6872                this.name = name; 
    6973                this.resourceLocator = createResourceLocator(); 
    7074        } 
     75   
     76  public Configuration getUserConfiguration() { 
     77    return configurationLoader.getUserConfiguration(); 
     78  } 
     79   
     80  public void saveUserConfiguration() throws ConfigurationException { 
     81    configurationLoader.saveUserConfiguration(); 
     82  } 
    7183 
    7284        private ResourceLocator createResourceLocator() { 
    …… 
    150162                boolean dryrun = line.hasOption(dryrunOption.getOpt()); 
    151163 
    152                 ConfigurationLoader loader = createConfigurationLoader(); 
    153                loader.setResourceLocator(getResourceLocator()); 
     164                configurationLoader = createConfigurationLoader(); 
     165    configurationLoader.setResourceLocator(getResourceLocator()); 
    154166 
    155167                if (line.hasOption(configOption.getOpt())) { 
    156                         URI userURI = new URI(line.getOptionValue(configOption.getOpt())); 
    157                         loader.setUserURI(userURI); 
     168                        URI commandLineURI = new URI(line.getOptionValue(configOption.getOpt())); 
     169                        configurationLoader.setCommandLineURI(commandLineURI); 
    158170                } 
    159171                if (line.hasOption(propertyOption.getOpt())) { 
    160172                        String values[] = line.getOptionValues(propertyOption.getOpt()); 
    161173                        for (int i = 0; i < values.length; i += 2) { 
    162                                 loader.addUserProperty(values[i], values[i + 1]); 
     174                                configurationLoader.addCommandLineProperty(values[i], values[i + 1]); 
    163175                        } 
    164176                } 
    165177 
    166                 loader.load(); 
    167  
    168                 this.configuration = loader.getRootConfiguration(); 
     178                configurationLoader.load(); 
     179 
     180                this.configuration = configurationLoader.getRootConfiguration(); 
    169181                postInit(configuration); 
    170182 

  • trunk/source/org/kolaka/freecast/config/ConfigurationLoader.java

    r893 r902  
    2626import java.net.URI; 
    2727 
     28import org.apache.commons.configuration.Configuration; 
    2829import org.apache.commons.configuration.ConfigurationException; 
    2930import org.apache.commons.configuration.HierarchicalConfiguration; 
    …… 
    4142  HierarchicalConfiguration getRootConfiguration(); 
    4243 
    43         void setUserURI(URI userURI); 
     44        void setCommandLineURI(URI userURI); 
    4445 
    45         void addUserProperty(String property, String value); 
     46        void addCommandLineProperty(String property, String value); 
    4647 
    4748        void setResourceLocator(ResourceLocator locator); 
     49   
     50  Configuration getUserConfiguration(); 
     51   
     52  void saveUserConfiguration() throws ConfigurationException; 
     53 
    4854} 

  • trunk/source/org/kolaka/freecast/config/Configurations.java

    r901 r902  
    3232  public static Configuration subset(Configuration parent, String prefix) { 
    3333    Configuration child = parent.subset(prefix); 
    34     return initFrom(child, parent); 
     34    return initFrom(child, parent); 
    3535  } 
    3636 
    …… 
    4141  public static Configuration initFrom(Configuration child, Configuration parent) { 
    4242     if (child instanceof HierarchicalConfiguration && parent instanceof HierarchicalConfiguration) { 
    43        initFrom((HierarchicalConfiguration) child, (HierarchicalConfiguration) parent); 
    4443     } else  if (child instanceof AbstractConfiguration && parent instanceof AbstractConfiguration) { 
    4544       initFrom((AbstractConfiguration) child, (AbstractConfiguration) parent); 

  • trunk/source/org/kolaka/freecast/config/DefaultConfigurationLoader.java

    r901 r902  
    2424package org.kolaka.freecast.config; 
    2525 
     26import java.io.File; 
    2627import java.net.URI; 
    2728import java.net.URL; 
    …… 
    3233import org.apache.commons.configuration.BaseConfiguration; 
    3334import org.apache.commons.configuration.CombinedConfiguration; 
     35import org.apache.commons.configuration.Configuration; 
    3436import org.apache.commons.configuration.ConfigurationException; 
    3537import org.apache.commons.configuration.DefaultConfigurationBuilder; 
     38import org.apache.commons.configuration.FileConfiguration; 
    3639import org.apache.commons.configuration.HierarchicalConfiguration; 
    3740import org.apache.commons.configuration.MapConfiguration; 
    3841import org.apache.commons.configuration.PropertiesConfiguration; 
    3942import org.apache.commons.configuration.XMLConfiguration; 
     43import org.apache.commons.lang.SystemUtils; 
    4044import org.apache.commons.logging.LogFactory; 
    4145import org.kolaka.freecast.resource.ResourceLocator; 
    …… 
    5155        private final String defaultsName; 
    5256 
    53         private URI userURI; 
    54  
    55         protected Properties userProperties = new Properties(); 
     57        private URI commandLineURI; 
     58 
     59  private File userFile = new File(new File(SystemUtils.USER_HOME, ".freecast"), "config.xml"); 
     60   
     61        protected Properties commandLineProperties = new Properties(); 
    5662 
    5763        protected HierarchicalConfiguration configuration; 
    …… 
    6268                this.locator = locator; 
    6369        } 
    64  
    65         public void setUserURI(URI userURI) { 
    66                 this.userURI = userURI; 
    67         } 
    68  
    69         public void addUserProperty(String property, String value) { 
    70                 userProperties.put(property, value); 
     70   
     71        public void setCommandLineURI(URI commandLineURI) { 
     72                this.commandLineURI = commandLineURI; 
     73        } 
     74   
     75        public void addCommandLineProperty(String property, String value) { 
     76                commandLineProperties.put(property, value); 
    7177        } 
    7278 
    …… 
    8894        } 
    8995 
    90         protected AbstractConfiguration loadUserConfiguration() 
     96        protected AbstractConfiguration loadCommandLineConfiguration() 
    9197                        throws ConfigurationException { 
    92                 if (userURI == null) { 
     98                if (commandLineURI == null) { 
    9399                        return new BaseConfiguration(); 
    94100                } 
    95101 
    96102                LogFactory.getLog(getClass()).debug( 
    97                                 "load the user configuration from " + userURI); 
     103                                "load the command line configuration from " + commandLineURI); 
    98104                XMLConfiguration configuration = new XMLConfiguration(); 
    99105                try { 
    100                         configuration.load(locator.openResource(userURI)); 
     106                        configuration.load(locator.openResource(commandLineURI)); 
    101107                } catch (ResourceLocator.Exception e) { 
    102108                        throw new ConfigurationException( 
    103                                         "Can't load the user configuration URI " + userURI, e); 
    104                 } 
    105                 return configuration; 
    106         } 
     109                                        "Can't load the command line configuration URI " + commandLineURI, e); 
     110                } 
     111                return configuration; 
     112        } 
     113   
     114  protected XMLConfiguration loadUserConfiguration() 
     115  throws ConfigurationException { 
     116    LogFactory.getLog(getClass()).debug( 
     117        "load the user configuration from " + userFile); 
     118    XMLConfiguration configuration = new XMLConfiguration(userFile); 
     119    configuration.setRootElementName("freecast"); 
     120    try { 
     121      configuration.load(); 
     122    } catch (ConfigurationException e) { 
     123      LogFactory.getLog(getClass()).info("no user configuration found"); 
     124      LogFactory.getLog(getClass()).debug( 
     125          "can't load user configuration from " + userFile, e); 
     126    } 
     127    return configuration; 
     128  } 
     129   
     130  public Configuration getUserConfiguration() { 
     131    return userConfiguration; 
     132  } 
     133   
     134  public void saveUserConfiguration() throws ConfigurationException { 
     135    userFile.getParentFile().mkdirs(); 
     136    userConfiguration.save(); 
     137  } 
    107138 
    108139        public HierarchicalConfiguration getRootConfiguration() { 
    …… 
    111142   
    112143  private static final AbstractConfiguration EMPTY_CONFIGURATION = new PropertiesConfiguration(); 
     144 
     145  private XMLConfiguration userConfiguration; 
    113146 
    114147        protected AbstractConfiguration loadDefaultConfiguration(String name) 
    …… 
    148181    configuration.setDelimiterParsingDisabled(true); 
    149182 
    150     if (!userProperties.isEmpty()) { 
    151                         LogFactory.getLog(getClass()).trace("use user properties: " + userProperties); 
     183    if (!commandLineProperties.isEmpty()) { 
     184                        LogFactory.getLog(getClass()).trace("use command line properties: " + commandLineProperties); 
    152185                        configuration 
    153                                         .addConfiguration(new MapConfiguration(userProperties)); 
    154                 } 
    155                 configuration.addConfiguration(loadUserConfiguration()); 
     186                                        .addConfiguration(new MapConfiguration(commandLineProperties)); 
     187                } 
     188                configuration.addConfiguration(loadCommandLineConfiguration()); 
     189    userConfiguration = loadUserConfiguration(); 
     190    configuration.addConfiguration(userConfiguration); 
    156191                completeConfiguration(configuration); 
    157192 

  • trunk/source/org/kolaka/freecast/config/InetSocketAddressConfigurator.java

    r883 r902  
    3030public class InetSocketAddressConfigurator { 
    3131 
     32  public static final String PROPERTY_PORT = "port"; 
     33  public static final String PROPERTY_HOST = "host"; 
     34 
    3235  public InetSocketAddress load(Configuration configuration) { 
    33     String host = configuration.getString("host", "0.0.0.0"); 
    34     int port = configuration.getInt("port"); 
     36    String host = configuration.getString(PROPERTY_HOST, "0.0.0.0"); 
     37    int port = configuration.getInt(PROPERTY_PORT); 
    3538     
    3639    return new InetSocketAddress(host, port); 
    3740  } 
    38  
     41   
    3942} 

  • trunk/source/org/kolaka/freecast/setup/Main.java

    r901 r902  
    2424package org.kolaka.freecast.setup; 
    2525 
     26import org.apache.commons.configuration.ConfigurationException; 
    2627import org.apache.commons.configuration.HierarchicalConfiguration; 
     28import org.apache.commons.configuration.XMLConfiguration; 
     29import org.apache.commons.logging.LogFactory; 
    2730import org.kolaka.freecast.config.Configurations; 
    2831import org.kolaka.freecast.swing.ConfigurableResources; 
    2932import org.kolaka.freecast.swing.Resources; 
    3033import org.kolaka.freecast.swing.SwingApplication; 
     34import org.kolaka.freecast.transport.receiver.ReceiverConfigurationLoader; 
    3135import org.kolaka.freecast.transport.receiver.TestReceiverConfiguration; 
    3236import org.pietschy.wizard.Wizard; 
    …… 
    5761      } 
    5862      public void wizardClosed(WizardEvent event) { 
    59         System.out.println(model.getConfiguration()); 
     63        // System.out.println(model.getConfiguration()); 
     64        new ReceiverConfigurationLoader().save(model.getConfiguration(), getUserConfiguration()); 
     65         
     66        try { 
     67          saveUserConfiguration(); 
     68        } catch (ConfigurationException e) { 
     69          LogFactory.getLog(Main.this.getClass()).error("can't save configuration", e); 
     70        } 
    6071        exit(); 
    6172      } 

  • trunk/source/org/kolaka/freecast/transport/receiver/PlaylistReceiver.java

    r883 r902  
    5454      long bandwidth =  
    5555        ((StaticBandwidthControler) bandwidthControler).getBandwidth() / FileUtils.ONE_KB; 
    56       configuration.setBandwidth(bandwidth); 
     56      configuration.setBandwidth((int) bandwidth); 
    5757    } 
    5858     

  • trunk/source/org/kolaka/freecast/transport/receiver/PlaylistReceiverConfiguration.java

    r883 r902  
    3333         
    3434        private URI uri; 
    35   private long bandwidth; 
     35  private int bandwidth; 
    3636 
    3737        public URI getUri() { 
    …… 
    4343        } 
    4444 
    45         public long getBandwidth() { 
     45        public int getBandwidth() { 
    4646                return bandwidth; 
    4747        } 
    4848 
    49         public void setBandwidth(long bandwidth) { 
     49        public void setBandwidth(int bandwidth) { 
    5050                this.bandwidth = bandwidth; 
    5151        } 

  • trunk/source/org/kolaka/freecast/transport/receiver/ReceiverConfigurationLoader.java

    r901 r902  
    2424package org.kolaka.freecast.transport.receiver; 
    2525 
     26import java.net.InetSocketAddress; 
    2627import java.net.URI; 
    2728import java.net.URISyntaxException; 
    2829 
     30import org.apache.commons.configuration.Configuration; 
    2931import org.apache.commons.configuration.ConfigurationException; 
    3032import org.apache.commons.configuration.DataConfiguration; 
    …… 
    3436 
    3537public class ReceiverConfigurationLoader { 
     38   
     39  private static final String PROPERTY_QUALITY = "quality"; 
     40  private static final String PROPERTY_SAMPLERATE = "sampleRate"; 
     41  private static final String PROPERTY_CHANNELS = "channels"; 
     42  private static final String CLASS_PLAYLISTENCODER = "encoder-playlist"; 
     43  private static final String PROPERTY_BANDWIDTH = "bandwidth"; 
     44  private static final String CLASS_PLAYLIST = "playlist"; 
     45  private static final String CLASS_SHOUTSERVER = "shoutserver"; 
     46  private static final String CLASS_TEST = "test"; 
     47  private static final String CLASS_PEER = "peer"; 
     48  private static final String CLASS_SHOUTCLIENT = "shoutclient"; 
     49 
     50  private static final String PROPERTY_CLASS = "class"; 
     51  private static final String PROPERTY_URL = "url"; 
     52  private static final String PROPERTY_LISTENADDRESS = "listenaddress"; 
     53   
     54  private static final String PREFIX = "node.receiver."; 
     55   
     56  private final InetSocketAddressConfigurator inetSocketAddressConfigurator = new InetSocketAddressConfigurator(); 
     57 
     58  /** 
     59   *  
     60   * TODO subset(...).setProperty doesn't work for HierarchicalConfiguration 
     61   */ 
     62  public void save(ReceiverConfiguration configuration, Configuration receiverConfiguration) { 
     63    if (configuration instanceof ShoutClientReceiverConfiguration) { 
     64      receiverConfiguration .setProperty(PREFIX + PROPERTY_CLASS, CLASS_SHOUTCLIENT); 
     65      ShoutClientReceiverConfiguration shoutClientReceiverConfiguration = (ShoutClientReceiverConfiguration) configuration; 
     66      receiverConfiguration.setProperty(PREFIX + PROPERTY_URL, shoutClientReceiverConfiguration.getUrl()); 
     67    } else if (configuration instanceof PeerReceiverConfiguration) { 
     68      receiverConfiguration.setProperty(PREFIX + PROPERTY_CLASS, CLASS_PEER); 
     69    } else if (configuration instanceof TestReceiverConfiguration) { 
     70      receiverConfiguration.setProperty(PREFIX + PROPERTY_CLASS, CLASS_TEST); 
     71    } else if (configuration instanceof ShoutServerReceiverConfiguration) { 
     72      receiverConfiguration.setProperty(PREFIX + PROPERTY_CLASS, CLASS_SHOUTSERVER); 
     73      ShoutServerReceiverConfiguration shoutServerReceiverConfiguration = (ShoutServerReceiverConfiguration) configuration; 
     74 
     75      InetSocketAddress address = shoutServerReceiverConfiguration.getListenAddress(); 
     76      String addressPrefix = PREFIX + "." + PROPERTY_LISTENADDRESS + "."; 
     77       
     78      receiverConfiguration.setProperty(addressPrefix + InetSocketAddressConfigurator.PROPERTY_HOST, address.getHostName()); 
     79      receiverConfiguration.setProperty(addressPrefix + InetSocketAddressConfigurator.PROPERTY_PORT, new Integer(address.getPort())); 
     80       
     81    } else if (configuration instanceof PlaylistReceiverConfiguration) { 
     82      receiverConfiguration.setProperty(PREFIX + PROPERTY_CLASS, CLASS_PLAYLIST); 
     83      PlaylistReceiverConfiguration playlistReceiverConfiguration = (PlaylistReceiverConfiguration) configuration; 
     84      receiverConfiguration.setProperty(PREFIX + PROPERTY_URL, playlistReceiverConfiguration.getUri()); 
     85      receiverConfiguration.setProperty(PREFIX + PROPERTY_BANDWIDTH, new Integer(playlistReceiverConfiguration.getBandwidth())); 
     86    } else if (configuration instanceof PlaylistEncoderReceiverConfiguration) { 
     87      receiverConfiguration.setProperty(PREFIX + PROPERTY_CLASS, CLASS_PLAYLISTENCODER); 
     88      PlaylistEncoderReceiverConfiguration playlistEncoderReceiverConfiguration = (PlaylistEncoderReceiverConfiguration) configuration; 
     89      receiverConfiguration.setProperty(PREFIX + PROPERTY_URL, playlistEncoderReceiverConfiguration.getUri()); 
     90      EncoderFormat encoderFormat = playlistEncoderReceiverConfiguration.getEncoderFormat(); 
     91      receiverConfiguration.setProperty(PREFIX + PROPERTY_CHANNELS, new Integer(encoderFormat.getChannels())); 
     92      receiverConfiguration.setProperty(PREFIX + PROPERTY_QUALITY, new Float(encoderFormat.getQuality())); 
     93      receiverConfiguration.setProperty(PREFIX + PROPERTY_SAMPLERATE, new Integer(encoderFormat.getSampleRate())); 
     94    } else { 
     95      throw new IllegalArgumentException("Unknown receiver : '" + configuration + "'"); 
     96    } 
     97  } 
    3698 
    3799  public ReceiverConfiguration load(DataConfiguration receiverConfiguration) 
    38100      throws ConfigurationException { 
    39     String receiverClass = receiverConfiguration.getString("class"); 
     101    String receiverClass = receiverConfiguration.getString(PROPERTY_CLASS); 
    40102 
    41     if (receiverClass.equals("shoutclient")) { 
     103    if (receiverClass.equals(CLASS_SHOUTCLIENT)) { 
    42104      ShoutClientReceiverConfiguration configuration = new ShoutClientReceiverConfiguration(); 
    43       configuration.setUrl(receiverConfiguration.getURL("url")); 
     105      configuration.setUrl(receiverConfiguration.getURL(PROPERTY_URL)); 
    44106      return configuration; 
    45107    } 
    46108 
    47     if (receiverClass.equals("peer")) { 
     109    if (receiverClass.equals(CLASS_PEER)) { 
    48110      return new PeerReceiverConfiguration(); 
    49111    } 
    50112 
    51     if (receiverClass.equals("test")) { 
     113    if (receiverClass.equals(CLASS_TEST)) { 
    52114      return new TestReceiverConfiguration(); 
    53115    } 
    54116 
    55     if (receiverClass.equals("shoutserver")) { 
     117    if (receiverClass.equals(CLASS_SHOUTSERVER)) { 
    56118      ShoutServerReceiverConfiguration configuration = new ShoutServerReceiverConfiguration(); 
    57       configuration.setListenAddress(new InetSocketAddressConfigurator() 
    58           .load(Configurations.subset(receiverConfiguration, "listenaddress"))); 
     119      configuration.setListenAddress(inetSocketAddressConfigurator 
     120          .load(Configurations.subset(receiverConfiguration, PROPERTY_LISTENADDRESS))); 
    59121      return configuration; 
    60122    } 
    61123 
    62     if (receiverClass.equals("playlist") 
    63         || receiverClass.equals("encoder-playlist")) { 
    64       String playlistURIString = receiverConfiguration.getString("url"); 
     124    if (receiverClass.equals(CLASS_PLAYLIST) 
     125        || receiverClass.equals(CLASS_PLAYLISTENCODER)) { 
     126      String playlistURIString = receiverConfiguration.getString(PROPERTY_URL); 
    65127      URI playlistURI = null; 
    66128      try { 
    …… 
    71133      } 
    72134 
    73       if (receiverClass.equals("playlist")) { 
     135      if (receiverClass.equals(CLASS_PLAYLIST)) { 
    74136        PlaylistReceiverConfiguration configuration = new PlaylistReceiverConfiguration(); 
    75137        configuration.setUri(playlistURI); 
    76138        configuration.setBandwidth(receiverConfiguration 
    77             .getInt("bandwidth", 40)); 
     139            .getInt(PROPERTY_BANDWIDTH, 40)); 
    78140 
    79141        LogFactory.getLog(getClass()).warn( 
    …… 
    84146        PlaylistEncoderReceiverConfiguration configuration = new PlaylistEncoderReceiverConfiguration(); 
    85147 
    86         int channels = receiverConfiguration.getInt("channels", 
     148        int channels = receiverConfiguration.getInt(PROPERTY_CHANNELS, 
    87149            EncoderFormat.DEFAULT.getChannels()); 
    88         int sampleRate = receiverConfiguration.getInt("sampleRate", 
     150        int sampleRate = receiverConfiguration.getInt(PROPERTY_SAMPLERATE, 
    89151            EncoderFormat.DEFAULT.getSampleRate()); 
    90         float quality = receiverConfiguration.getFloat("quality", 
     152        float quality = receiverConfiguration.getFloat(PROPERTY_QUALITY, 
    91153            EncoderFormat.DEFAULT.getQuality()); 
    92154