LoadModule ssl_module modules/mod_ssl.so
Listen 443
NameVirtualHost *:443

SSLPassPhraseDialog  builtin
SSLSessionCache         shmcb:/var/cache/mod_ssl/scache(512000)
SSLSessionCacheTimeout  300
SSLMutex default
SSLRandomSeed startup file:/dev/urandom  256
SSLRandomSeed connect builtin
SSLCryptoDevice builtin

SSLStrictSNIVHostCheck on

<VirtualHost *:443>
  ServerName dev.deltacloud.org

  ErrorLog logs/ssl_dev_error_log
  TransferLog logs/ssl_dev_access_log
  LogLevel warn
  SSLEngine on
  SSLProtocol all -SSLv2
  SSLCipherSuite ALL:!ADH:!EXPORT:!SSLv2:RC4+RSA:+HIGH:+MEDIUM:+LOW
  SSLCertificateFile /etc/pki/tls/certs/dev.crt
  SSLCertificateKeyFile /etc/pki/tls/private/deltacloud.key
  <Files ~ "\.(cgi|shtml|phtml|php3?)$">
      SSLOptions +StdEnvVars
  </Files>
  <Directory "/var/www/cgi-bin">
      SSLOptions +StdEnvVars
  </Directory>
  SetEnvIf User-Agent ".*MSIE.*" \
           nokeepalive ssl-unclean-shutdown \
           downgrade-1.0 force-response-1.0
  CustomLog logs/ssl_request_log \
            "%t %h %{SSL_PROTOCOL}x %{SSL_CIPHER}x \"%r\" %b"

  ProxyPass / http://localhost:3002/
  ProxyPassReverse / http://localhost:3002/
  ProxyPreserveHost On
  RequestHeader set X_FORWARDED_SCHEME 'https'
  Header add X-Deltacloud-Stability development
</VirtualHost>

<VirtualHost *:80>
  ServerName dev.deltacloud.org

  ErrorLog logs/dev_error_log
  TransferLog logs/dev_access_log
  LogLevel warn
  SetEnvIf User-Agent ".*MSIE.*" \
           nokeepalive ssl-unclean-shutdown \
           downgrade-1.0 force-response-1.0

  ProxyPass / http://localhost:3002/
  ProxyPassReverse / http://localhost:3002/
  ProxyPreserveHost On
  RequestHeader set X_FORWARDED_SCHEME 'http'
  Header add X-Deltacloud-Stability development
</VirtualHost>

<VirtualHost *:443>
  ServerName api.deltacloud.org

  ErrorLog logs/ssl_error_log
  TransferLog logs/ssl_access_log
  LogLevel warn
  SSLEngine on
  SSLProtocol all -SSLv2
  SSLCipherSuite ALL:!ADH:!EXPORT:!SSLv2:RC4+RSA:+HIGH:+MEDIUM:+LOW
  SSLCertificateFile /etc/pki/tls/certs/api.crt
  SSLCertificateKeyFile /etc/pki/tls/private/deltacloud.key
  <Files ~ "\.(cgi|shtml|phtml|php3?)$">
      SSLOptions +StdEnvVars
  </Files>
  <Directory "/var/www/cgi-bin">
      SSLOptions +StdEnvVars
  </Directory>
  SetEnvIf User-Agent ".*MSIE.*" \
           nokeepalive ssl-unclean-shutdown \
           downgrade-1.0 force-response-1.0
  CustomLog logs/ssl_request_log \
            "%t %h %{SSL_PROTOCOL}x %{SSL_CIPHER}x \"%r\" %b"

  ProxyPass / http://localhost:3001/
  ProxyPassReverse / http://localhost:3001/
  ProxyPreserveHost On
  RequestHeader set X_FORWARDED_SCHEME 'https'
  Header add X-Deltacloud-Stability stable
</VirtualHost>

Redirect permanent / https://api.deltacloud.org/
