This resource allows you to manage a SAF remote contexts in a JMS Module of a WebLogic domain.

Here is an example on how you should use this:

    wls_saf_remote_context { 'jmsClusterModule:RemoteSAFContext-0':
      ensure        => 'present',
      connect_url   => 't3://10.10.10.10:7001',
      weblogic_user => 'weblogic',
      weblogic_password => 'weblogic1',
    }

In this example you are managing a SAF remote contexts in the default domain. When you want to
manage a SAF remote contexts in a specific domain, you can use:

    wls_saf_remote_context { 'my_domain/jmsClusterModule:RemoteSAFContext-1':
      ensure      => 'present',
      connect_url => 't3://10.10.10.10:7001',
    }

This resource allows you to manage a file persistence stores in an WebLogic domain.

Here is an example on how to use the `wls_file_persistence_store`:


    # this will use default as wls_setting identifier
    wls_file_persistence_store{'jmsFile1':
      ensure     => 'present',
      directory  => 'persistence1',
      target     => ['wlsServer1'],
      targettype => ['Server'],
    }

In this example you are managing a file persistence store in the default domain. When you want to
manage a file persistence store in a specific domain, you can use:

    wls_file_persistence_store{'mydomain/jmsFile2':
      ensure     => 'present',
      directory  => 'persistence2',
      target     => ['wlsServer2'],
      targettype => ['Server'],
    }

This resource allows you to manage virtual targets in an WebLogic 12.2.1 domain.

This resource allows you to manage server templates in an WebLogic domain.

Here is an example on how you should use this:

    wls_server_template { 'ServerTemplateWeb':
      ensure        => 'present',
      arguments     => ['-XX:PermSize=256m','-XX:MaxPermSize=256m'],
      listenport    => '9101',
      sslenabled    => 1,
      ssllistenport => '9102',
    }

In this example you are managing a server template in the default domain. When you want to
manage a server template in a specific domain, you can use:

    wls_server_template { 'my_domain/ServerTemplateWeb':
      ensure        => 'present',
      arguments     => ['-XX:PermSize=256m','-XX:MaxPermSize=256m'],
      listenport    => '9101',
      sslenabled    => 1,
      ssllistenport => '9102',
    }

This resource allows you to execute a wlst command or script in the context.

This is a fallback resource. This means you should use it with care and only if there are no other Puppet types available.
Here is an example on how you can use this:

    wls_exec{'@/tmp/set_some_configuration.py':
      cwd         => '/tmp',
      refreshonly => true,
      logoutput   => true,
      unless      => '@/tmp/configuration_is_not_set.py',
    }

This statement will first execute the `/tmp/configuration_is_not_set.py` script. If this script returns
something, the main script (e.g. `/tmp/set_some_configuration.py`) will not be executed. If it returns nothing,
the `/tmp/set_some_configuration.py` script is executed.

Here is an example of a part of the unless script:

    if resource_available:
      print >>puppet, "true"

If the resource is available, you must write something to `puppet`. If the resource is not available,
do nothing.

**Formatting**

Because Python is sensitive for formatting, you should take care the formatting of the main and the
unless scripts. You **MUST** start both scripts at column 0.

You can also explicitly specify the domain:

    wls_exec{'my_domain/@/tmp/set_some_configuration.py':
      cwd         => '/tmp',
      refreshonly => true,
      logoutput   => true,
      unless      => '@/tmp/configuration_is_not_set.py',
    }

This resource allows you to manage deployments in a resource group of a domain partition in an WebLogic 12.2.1 domain.

This resource allows you to manage a JMS module in an WebLogic domain.

Here is an example on how you should use this:

    wls_jms_module { 'jmsClusterModule':
      ensure     => 'present',
      target     => ['WebCluster'],
      targettype => ['Cluster'],
    }

In this example you are managing a JMS module in the default domain. When you want to
manage a JMS module in a specific domain, you can use:

    wls_jms_module { 'my_domain/jmsClusterModule':
      ensure     => 'present',
      target     => ['WebCluster'],
      targettype => ['Cluster'],
    }

This resource allows you to manage domain partitions in an WebLogic 12.2.1 domain.

This resource allows you to manage foreign servers in a JMS Module of a WebLogic domain.

Here is an example on how you should use this:

    wls_foreign_server { 'jmsClusterModule:AQForeignServer':
      ensure                => 'present',
      defaulttargeting      => 1,
      extraproperties       => 'datasource=jdbc/hrDS',
      initialcontextfactory => ['oracle.jms.AQjmsInitialContextFactory'],
    }

In this example you are managing a foreign server in the default domain. When you want to
manage a foreign server in a specific domain, you can use:

    wls_foreign_server { 'my_domain/jmsClusterModule:Jboss':
      ensure                => 'present',
      connectionurl         => 'remote://10.10.10.10:4447',
      defaulttargeting      => '0',
      extraproperties       => ['java.naming.security.principal=jmsuser'],
      initialcontextfactory => 'org.jboss.naming.remote.client.InitialContextFactory',
      subdeployment         => 'wlsServers',
    }

This resource allows you to set the defaults for all other wls types.

All wls types needs a `wls_setting` definition. This is a pointer to an WebLogic AdminServer and
you need to create one for every WebLogic domain. When you don't provide a `wls_setting` identifier
in the title of the weblogic type then it will use `default` as identifier.

Here is an example on how to create the `default` settings:

    wls_setting { 'default':
      user               => 'oracle',
      weblogic_home_dir  => '/opt/oracle/middleware11g/wlserver_10.3',
      connect_url        => "t3://localhost:7001",
      weblogic_user      => 'weblogic',
      weblogic_password  => 'weblogic1',
    }

When you want to create an other domain, like for instance `domain2`. You use `wls_setting like this:

    wls_setting { 'domain2':
      user               => 'oracle',
      weblogic_home_dir  => '/opt/oracle/middleware11g/wlserver_10.3',
      connect_url        => "t3://localhost:7011",
      weblogic_user      => 'weblogic',
      weblogic_password  => 'weblogic1',
      post_classpath     => '/opt/oracle/wlsdomains/domains/Wls1036/lib/aa.jar',
      extra_properties   => ['wls_server:.*'],
    }

This resource allows you to manage a Queue in a JMS Module of a WebLogic domain.

Here is an example on how you should use this:

    wls_jms_queue { 'jmsClusterModule:ErrorQueue':
      ensure            => 'present',
      defaulttargeting  => '0',
      distributed       => 1,
      expirationpolicy  => 'Discard',
      jndiname          => 'jms/ErrorQueue',
      redeliverydelay   => '-1',
      redeliverylimit   => '-1',
      subdeployment     => 'jmsServers',
      timetodeliver     => '-1',
      timetolive        => '-1',
      templatename      => 'Template',
      messagelogging    => 1,
      consumptionpaused => '0',
      insertionpaused   => '0',
      productionpaused  => '0',
    }

This resource allows you to manage authentication providers in a WebLogic domain.

Here is an example on how you should use this:

    wls_authentication_provider { 'ldap':
      ensure            => 'present',
      control_flag      => 'SUFFICIENT',
      providerclassname => 'weblogic.security.providers.authentication.LDAPAuthenticator',
      attributes:       =>  'Principal;Host;Port;CacheTTL;CacheSize;MaxGroupMembershipSearchLevel;SSLEnabled',
      attributesvalues  =>  'ldapuser;ldapserver;389;60;1024;4;1',
      order             =>  '0'
    }

To manage Weblogic's DefaultIdentityAsserter use the wls_identity_asserter type. In this example
you are managing a provider in the default domain. When you want to
manage a provider in a specific domain, you can use:

    wls_authentication_provider { 'MyDomain/MyAuthenticationProvider':
      ensure           => 'present',
    }

Check [the Oracle Weblogic documentation](http://docs.oracle.com/middleware/1221/wls/INTRO/clustering.htm#INTRO185)
for more documentation about setting up and managing a WebLogic cluster.

This resource allows you to manage group in a WebLogic Security Realm.

Here is an example on how you should use this:

    wls_group { 'SuperUsers':
      ensure                 => 'present',
      authenticationprovider => 'DefaultAuthenticator',
      description            => 'SuperUsers',
      realm                  => 'myrealm',
      users                  => ['testuser2'],
    }

In this example you are managing a group in the default domain. When you want to
manage a group in a specific domain, you can use:

    wls_group { 'my_domain/TestGroup':
      ensure                 => 'present',
      authenticationprovider => 'DefaultAuthenticator',
      description            => 'TestGroup',
      realm                  => 'myrealm',
      users                  => ['testuser1','testuser2'],
    }

This resource allows you to manage the sort destination key in a JMS module of a WebLogic domain.

Here is an example on how you should use this:

    wls_jms_sort_destination_key { 'jmsClusterModule:JMSPriority':
      ensure        => 'present',
      key_type      => 'Int',
      property_name => 'JMSPriority',
      sort_order    => 'Descending',
    }

In this example you are managing a JMS sort destination key in the default domain. When you want to
manage a JMS sort destination key in a specific domain, you can use:

    wls_jms_sort_destination_key { 'my_domain/jmsClusterModule:JMSRedelivered':
      ensure        => 'present',
      key_type      => 'Boolean',
      property_name => 'JMSRedelivered',
      sort_order    => 'Ascending',
    }

This resource allows you to manage a mail_session in an WebLogic domain.

Here is an example on how you should use this:

    wls_mail_session { 'myMailSession':
      ensure         => 'present',
      jndiname       => 'myMailSession',
      target         => ['ManagedServer1', 'WebCluster'],
      targettype     => ['Server', 'Cluster'],
      mailproperty   => ['mail.host=smtp.hostname.com', 'mail.user=smtpadmin'],
    }

In this example you are managing a mail session in the default domain. When you want to
manage a mail session in a specific domain, you can use:

    wls_mail_session { 'my_domain/myMailSession':
      ensure         => 'present',
      jndiname       => 'myMailSession',
      target         => ['ManagedServer1', 'WebCluster'],
      targettype     => ['Server', 'Cluster'],
      mailproperty   => ['mail.host=smtp.hostname.com', 'mail.user=smtpadmin'],
    }

This resource allows you to manage a JDBC persistence stores in an WebLogic domain.

Here is an example on how you should use this:

    wls_jdbc_persistence_store { 'JDBCStoreX':
      ensure      => 'present',
      datasource  => 'jmsDS',
      prefix_name => 'dev_',
      target      => ['wlsServer1'],
      targettype  => ['Server'],
    }

In this example you are managing a JDBC persistance store in the default domain. When you want to
manage a JDBC persistance store in a specific domain, you can use:

    wls_jdbc_persistence_store { 'my_domain/JDBCStoreX':
      ensure      => 'present',
      datasource  => 'jmsDS',
      prefix_name => 'dev_',
      target      => ['wlsServer1'],
      targettype  => ['Server'],
    }

This resource allows you to manage a connection factory in a JMS Module of a WebLogic domain.

Here is an example on how you should use this:

    wls_jms_connection_factory { 'jmsClusterModule:cf':
      ensure                    => 'present',
      attachjmsxuserid          => '0',
      clientidpolicy            => 'Restricted',
      defaulttargeting          => '0',
      jndiname                  => 'jms/cf',
      loadbalancingenabled      => 1,
      messagesmaximum           => '10',
      reconnectpolicy           => 'producer',
      serveraffinityenabled     => 1,
      subdeployment             => 'wlsServers',
      subscriptionsharingpolicy => 'Exclusive',
      transactiontimeout        => '3600',
      xaenabled                 => '0',
    }

In this example you are managing a connection factory in the default domain. When you want to
manage a connection factory in a specific domain, you can use:

    wls_jms_connection_factory { 'my_domain/jmsClusterModule:cf2':
      ensure                    => 'present',
      attachjmsxuserid          => '0',
      clientidpolicy            => 'Restricted',
      defaulttargeting          => 1,
      jndiname                  => 'jms/cf2',
      loadbalancingenabled      => 1,
      messagesmaximum           => '10',
      reconnectpolicy           => 'producer',
      serveraffinityenabled     => 1,
      subscriptionsharingpolicy => 'Exclusive',
      transactiontimeout        => '3600',
      xaenabled                 => 1,
    }

This resource allows you to manage a SAF agent in an WebLogic domain.

Here is an example on how you should use this:

    wls_safagent { 'jmsSAFAgent1':
      ensure              => 'present',
      persistentstore     => 'jmsFileSAFAgent1',
      persistentstoretype => 'FileStore',
      servicetype         => 'Sending-only',
      target              => ['wlsServer1'],
      targettype          => ['Server'],
    }

In this example you are managing a SAF agent in the default domain. When you want to
manage a SAF agent in a specific domain, you can use:

    wls_safagent { 'my_domain/jmsSAFAgent2':
      ensure      => 'present',
      servicetype => 'Both',
      target      => ['wlsServer2'],
      targettype  => ['Server'],
    }

This resource allows you to manage machine in an WebLogic domain.

Here is an example on how you should use this:

    wls_machine { 'test2':
      ensure        => 'present',
      listenaddress => '10.10.10.10',
      listenport    => '5556',
      machinetype   => 'UnixMachine',
      nmtype        => 'SSL',
    }

In this example you are managing a machine in the default domain. When you want to
manage a machine in a specific domain, you can use:

    wls_machine { 'my_domain/test2':
      ensure        => 'present',
      listenaddress => '10.10.10.10',
      listenport    => '5556',
      machinetype   => 'UnixMachine',
      nmtype        => 'SSL',
    }

This resource allows you to manage a SAF imported destinations object in a JMS Module of a WebLogic domain.

Here is an example on how you should use this:

    wls_saf_imported_destination_object { 'jmsClusterModule:SAFImportedDestinations-0:SAFDemoQueue':
      ensure               => 'present',
      nonpersistentqos     => 'Exactly-Once',
      object_type          => 'queue',
      remotejndiname       => 'jms/DemoQueue',
      unitoforderrouting   => 'Hash',
      usetimetolivedefault => '0',
    }

In this example you are managing a SAF imported destination object in the default domain. When you want to
manage a SAF imported destination object in a specific domain, you can use:

    wls_saf_imported_destination_object { 'my_domain/jmsClusterModule:SAFImportedDestinations-0:SAFDemoTopic':
      ensure               => 'present',
      nonpersistentqos     => 'Exactly-Once',
      object_type          => 'topic',
      remotejndiname       => 'jms/DemoTopic',
      timetolivedefault    => '100000000',
      unitoforderrouting   => 'Hash',
      usetimetolivedefault => 1,
    }

This resource allows you to manage security authorization policies in an WebLogic Security Realm.

This resource allows you to manage a coherence cluster in a WebLogic domain.

  Here is an example on how you should use this:

      wls_coherence_cluster { 'WebCoherenceCluster':
        ensure          => 'present',
        clusteringmode  => 'unicast',
        multicastport   => '33389',
        target          => ['WebCluster'],
        targettype      => ['Cluster'],
        unicastport     => '9999',
        storage_enabled =>  '1',
      }

  In this example you are managing a cluster in the default domain. When you want to
  manage a coherence cluster in a specific domain, you can use:

      wls_coherence_cluster { 'my_domain/defaultCoherenceCluster':
        ensure         => 'present',
        clusteringmode => 'unicast',
        multicastport  => '33387',
        unicastport    => '8888',
      }

  Check [the Oracle Weblogic documentation](http://docs.oracle.com/middleware/1221/wls/INTRO/domains.htm#INTRO330)
  for more documentation about setting up and managing a coherence cluster.

This resource allows you to manage a coherence server in an WebLogic domain.

Here is an example on how you should use this:

    wls_coherence_server { 'default':
      ensure         => 'present',
      server         => 'LocalMachine',
      unicastaddress => 'localhost',
      unicastport    => '8888',
    }

In this example you are managing a server in the default domain. When you want to
manage a coherence server in a specific domain, you can use:

    wls_coherence_server { 'my_domain/default':
      ensure         => 'present',
      server         => 'LocalMachine',
      unicastaddress => 'localhost',
      unicastport    => '8888',
    }

Check [the Oracle Weblogic documentation](https://docs.oracle.com/middleware/1212/coherence/COHMG/toc.htm)
for more documentation about setting up and managing a coherence server.

This resource allows you to manage Identity Asserters in an WebLogic domain.

Here is an example on how you should use this:

    wls_authentication_provider { 'DefaultIdentityAsserter':
      ensure            => 'present',
      providerclassname => 'weblogic.security.providers.authentication.DefaultIdentityAsserter',
      attributes:       => 'DigestReplayDetectionEnabled;UseDefaultUserNameMapper',
      attributesvalues  => '1;1;',
      activetypes       => 'AuthenticatedUser::X.509',
      defaultmappertype => 'CN',
    }


In this example you are managing a identity asserter in the default domain. When you want to
manage a identity asserter in a specific domain, you can use:

    wls_authentication_provider { 'my_domain/DefaultIdentityAsserter':
      ensure            => 'present',
      providerclassname => 'weblogic.security.providers.authentication.DefaultIdentityAsserter',
      attributes:       => 'DigestReplayDetectionEnabled;UseDefaultUserNameMapper',
      attributesvalues  => '1;1;',
      activetypes       => 'AuthenticatedUser::X.509',
      defaultmappertype => 'CN',
    }

This resource allows you to manage a jmsserver in an WebLogic domain.

Here is an example on how you should use this:

    wls_jmsserver { 'jmsServer1':
      ensure                      => 'present',
      persistentstore             => 'jmsFile1',
      persistentstoretype         => 'FileStore',
      target                      => ['wlsServer1'],
      targettype                  => ['Server'],
      allows_persistent_downgrade => '0',
      bytes_maximum               => '-1',
    }

In this example you are managing a JMS server in the default domain. When you want to
manage a JMS server in a specific domain, you can use:

    wls_jmsserver { 'my_domain/jmsServer2':
      ensure     => 'present',
      target     => ['wlsServer2'],
      targettype => ['Server'],
    }

This resource allows you to manage a foreign jndi provider in an WebLogic domain.

Here is an example on how you should use this:

    wls_foreign_jndi_provider { 'DomainA':
      ensure                  => 'present',
      initial_context_factory => 'weblogic.jndi.WLInitialContextFactory',
      provider_properties     => ['bbb=aaaa', 'xxx=123'],
      provider_url            => 't3://10.10.10.100:7001',
      target                  => ['WebCluster'],
      targettype              => ['Cluster'],
      user                    => 'weblogic',
      password                => 'weblogic1',
    }

In this example you are managing a foreign jndi provider in the default domain. When you want to
manage a foreign jndi provider in a specific domain, you can use:


    wls_foreign_jndi_provider { 'my_domain/LDAP':
      ensure                  => 'present',
      initial_context_factory => 'com.sun.jndi.ldap.LdapCtxFactory',
      provider_properties     => ['referral=follow'],
      provider_url            => 'ldap://:10.10.10.100:389',
      target                  => ['AdminServer'],
      targettype              => ['Server'],
      user                    => 'cn=orcladmin',
      password                => 'weblogic1',
    }

This resource allows you to manage resource group template in an WebLogic 12.2.1 domain.

This resource allows you to manage a template in a JMS Module of a WebLogic domain.

Here is an example on how you should use this:

    wls_jms_template { 'jmsClusterModule:Template-0':
      ensure          => 'present',
      redeliverydelay => '-1',
      redeliverylimit => '-1',
    }

In this example you are managing a JMS template in the default domain. When you want to
manage a JMS template in a specific domain, you can use:

    wls_jms_template { 'my_domain/jmsClusterModule:Template-0':
      ensure          => 'present',
      redeliverydelay => '-1',
      redeliverylimit => '-1',
    }

This resource allows you to managed migratable targets in a WebLogic domain.

Here is an example on how you should use this:

    wls_migratable_target { 'wlsServer1 (migratable)':
      ensure                     => 'present',
      cluster                    => 'WebCluster',
      migration_policy           => 'manual',
      number_of_restart_attempts => '6',
      seconds_between_restarts   => '30',
      user_preferred_server      => 'wlsServer1',
    }

In this example you are managing a migratable target in the default domain. When you want to
manage a migratable target in a specific domain, you can use:

    wls_migratable_target { 'my_domain/wlsServer2 (migratable)':
      ensure                     => 'present',
      cluster                    => 'WebCluster',
      migration_policy           => 'manual',
      number_of_restart_attempts => '6',
      seconds_between_restarts   => '30',
      user_preferred_server      => 'wlsServer2',
    }

Here are some more examples:

    wls_migratable_target { 'Wls11gSetting/wlsServer1 (migratable)':
      ensure                     => 'present',
      cluster                    => 'WebCluster',
      migration_policy           => 'manual',
      number_of_restart_attempts => '6',
      seconds_between_restarts   => '30',
      user_preferred_server      => 'wlsServer1',
    }
    wls_migratable_target { 'Wls11gSetting/wlsServer2 (migratable)':
      ensure                     => 'present',
      cluster                    => 'WebCluster',
      migration_policy           => 'manual',
      number_of_restart_attempts => '6',
      seconds_between_restarts   => '30',
      user_preferred_server      => 'wlsServer2',
    }

This resource allows you to manage a JMS subdeployment in a JMS module of a WebLogic domain.

Here is an example on how you should use this:

    wls_jms_subdeployment { 'jmsClusterModule:jmsServers':
      ensure     => 'present',
      target     => ['jmsServer1','jmsServer2'],
      targettype => ['JMSServer','JMSServer'],
    }

In this example you are managing a JMS subdeployment in the default domain. When you want to
manage a JMS subdeployment in a specific domain, you can use:

    wls_jms_subdeployment { 'my_domain/jmsClusterModule:wlsServers':
      ensure     => 'present',
      target     => ['WebCluster'],
      targettype => ['Cluster'],
    }