All Downloads are FREE. Search and download functionalities are using the official Maven repository.

schemaorg_apache_xmlbeans.src.geronimo-module-1.2.xsd Maven / Gradle / Ivy

The newest version!





    
        
            This is an XML Schema Definition for Geronimo service deployment
            plan. This deployment plan is used for deploying service modules
            which contains non-application GBeans like thread pool, the
            tomcat/jetty container, security manager, etc. In case the Service
            deployment plan is provided internally in the java archive, it
            should be named META-INF/geronimo-service.xml. In case the Service
            deployment plan is provided externally, the deployment descriptor
            can be named anything and provided to the deploy tool. All the
            Service deployment plan must specify the top level element as module
            with namespace specified as 
            xmlns="http://geronimo.apache.org/xml/ns/deployment-1.2". The default
            location for this document is
            http://geronimo.apache.org/xml/ns/deployment-1.2

            Typical Geronimo Service Deployment plan will look like this:
            
            
                
                    ...
                
                
                    ...
                
            
            ]]>
        
    

    
        
            
                The module element is the root element of the deployment plan
                for the Geronimo Service module. Note that the sub-elements of
                this element should be as in the given order in a sequence. It
                includes two basic sections, environment section to provide
                information like moduleName, dependencies, etc. and gbean
                section to provide information about individual beans contained
                in this module.
            
        
    

    
        
            
                
                    
                        Reference to environment element defined later in this
                        xsd.
                    
                
            
            
                
                    
                        Reference to service element defined later in this xsd.
                    
                
            
        
    

    
        
            
                The environment element defines elements to store information
                like moduleId, dependencies, and classloader Info for the
                module. This element is used in all the Services and application
                modules deployment plans.
            
        

        

    
    
        
            
                The client-environment element is used only by Application
                Client modules to provide client module environment setting. It
                defines elements to store information like moduleId,
                dependencies, and classloader Info for the client-side
                application module. This information is used to identify the
                module in the client container only and it should not be
                directly used by deployment process.
            
        
    

    
        
            
                The server-environment element is used only by Application
                Client modules to define server side module environment
                settings. It defines elements to store information like
                moduleId, dependencies, and classloader Info for the server-side
                of client application module. This information is used to
                identify the module in the server environment only.
            
        
    

    
        
            
                
                    
                        "moduleId" holds elements for the groupId, artifactId,
                        and version of the module version can be ommitted in
                        which case a timestamp is used. Module IDs are normally
                        printed with slashes between the four components, such
                        as GroupID/ArtifactID/Version/Type.
                    
                
            
            
                
                    
                        "dependencies" holds all classloader and dependency
                        information for the module
                    
                
            
            
            
            
            
            
            

            
                
                    
                        A list of classes which will never be loaded from parent
                        ClassLoaders of this module. For example, if Log4J was
                        listed here, the module would never see Geronimo's copy
                        of Log4J. If the module provided it's own Log4J JAR it
                        would use that, otherwise it would not be able to load
                        Log4J at all.

                        The classes are specified in zero or more child "filter"
                        elements where each filter element specifies a
                        fully-qualified class name or prefix. Essentially, any
                        class that starts with one of the prefixes listed here
                        will be treated as hidden. For example, if you specify
                        two filter elements containing "java.util" and
                        "java.lang" then you would really screw up your
                        application. :)
                    
                
            
            
                
                    
                        A list of classes which will only be loaded from parent
                        ClassLoaders of this module (never from the module's own
                        ClassLoader). For example, this is used to prevent a web
                        application from redefining "javax.servlet", so those
                        classes will *always* be loaded from the server instead
                        of from the web web application's own ClassPath.

                        The classes are specified in zero or more child "filter"
                        elements where each filter element specifies a
                        fully-qualified class name or prefix. Essentially, any
                        class that starts with one of the prefixes listed here
                        will be treated as hidden. For example, specifying two
                        filter elements containing "javax.servlet" and
                        "javax.ejb" would protect some of the core J2EE classes
                        from being overridden.
                    
                
            
            
                
                    
                        A list of classes which will only be loaded from the
                        ClassLoader of this module or from parent ClassLoaders.
                        
                        This is used to prevent children configurations to see
                        specific classes from its parents. The same effect can
                        be achieved by using hidden-classes. However,
                        private-classes is the preferred approach to hide 
                        specific classes from all children configurations. 
                    
                
            
            
                
                    
                        If the "inverse-classloading" element is specified, the
                        standard class loading delegation model is to be
                        reversed for this module.
                    
                
            
            
                
                    
                        If the "suppress-default-environment" element is
                        specified then any default environment build by a
                        builder when deploying the plan will be suppressed.

                        An example of where this is useful is when deploying a
                        connector on an app client in a separate (standalone)
                        module (not as part of a client plan).

                        The connector builder defaultEnvironment includes some
                        server modules that won't work on an app client, so you
                        need to suppress the default environment and supply a
                        complete environment including all parents for a
                        non-app-client module you want to run on an app client
                    
                
            
        
    

    

    
        
            
                
                    
                        "dependency" holds an artifact locating an artifact in a
                        repository. Depending on the type of artifact and value
                        of the import element, the artifact may be included in
                        the current classpath, be loaded as a parent, may
                        require the services in the artifact to be started, or
                        may not be added to the classpath.
                    
                
            
        
    

    

    
        
            
                An empty generic element to be extended by gbean and other
                module types.
            
        
    

    
        
    

    
        
            
                Adds a new custom component to the server. The component will be
                deployed when this application module is deployed, but it is not
                in any way protected, so once it is up and running, other
                modules can refer to it normally.
            
        
    

    
        
            
                
                    
                        A fully-qualified class name or prefix to be filtered.
                    
                
            
        
    

    
        
            
                postgresql
                postgresql-8.0-jdbc
                313
                jar
	            ]]>
            
        
        
            
            
                
                    
                        The name for group containing this module. By default,
                        it is considered 'default' for declaration and wild card
                        '*' for dependencies.
                    
                
            
            
                
                    
                        The name for module in a specified group. All the
                        artifactId's should be unique within a group. If no
                        articfactId is provided it will be defaulted to file
                        name of the module file.
                    
                
            
            
                
                    
                        The version number for the module formatted by dot
                        separated numbers. If no version is provided it will be
                        defaulted to numeric timestamp generated by
                        System.currentTimeMillis() at deploy time. In case of
                        dependencies latest available version will be used.
                    
                
            
            
                
                    
                        This element defines the type of the module. The type
                        could be 'CAR', 'JAR', EAR', 'WAR', etc. If no type is
                        provided it will be defaulted appropriately by the
                        deployer depending upon type of deployed module.
                    
                
            
        
    

    
        
            
                
                    
                        DependencyType includes all the elements defined in
                        artifactType.
                    
                
                
                    
                        
                            
                                The import element is restrictive element to
                                defined type of dependency. The default (when
                                omitted) is to include the specified dependency
                                in the classloader (as a parent or URL). If
                                defined as "classes" means that the classes must
                                be included in the current module's classloader
                                but the dependency does not need to be started.
                                Specifying "services" means that the dependency
                                (a module) must be started before the current
                                module, but it is not included as a parent
                                classloader.
                            
                        
                    
                

            
        
    

    
        
            
                
            
        
        
            
                
                    
                        The value "classes" means that the classes must be
                        included in the current module's classloader but the
                        dependency does not need to be started.
                    
                
            
            
                
                    
                        The value "services" means that the dependency (a
                        module) must be started before the current module, but
                        it is not included as a parent classloader.
                    
                
            
        
    

    
        
            
                
                    
                        gbeanType includes all the elements defined in
                        abstract-serviceType.
                    
                

                
                    
                        
                            
                                The attribute provide the name-value pair of
                                various attributes for this GBean. The value of
                                the attributes is specified by value of this
                                element.
                            
                        
                    
                    
                        
                            
                                The xml-attribute specifies the value of
                                particular attribute in XML format, which will
                                be interpreted by a component running in the
                                system, which convert it to single value for
                                this attribute.
                            
                        
                    
                    
                        
                            
                                The "reference" element specifies the value of a
                                particular reference for this GBean in simplest
                                form. It holds the reference to the GBean that
                                matches the single pattern specified here, if no
                                value is specified it will refer to all the
                                matching GBeans.
                            
                        
                    
                    
                        
                            
                                The "references" element specifies the value of
                                a particular reference for this GBean matching
                                multiple pattern elements.
                            
                        
                    
                    
                        
                            
                                The xml-reference specifies the value of
                                particular reference in XML format, which will
                                be interpreted by a component running in the
                                system, which convert it to single value for
                                this reference.
                            
                        
                    
                    
                        
                            
                                The element "dependency" is used to resolve
                                dependencies at GBean level. This is normally
                                only used if for some reason the GBeans within a
                                module must be started in a certain order that
                                is not reflected in the references between them.
                            
                        
                    
                
                
                    
                        
                            A unique name for this GBean within this module,
                            this name will be used as a name component in
                            AbstractName, hence AbstractName will be unique
                            server wide.
                        
                    
                
                
                    
                        
                            The fully-qualified name of the class containing the
                            GBeanInfo for this GBean.
                        
                    
                
            
        
    

    
        
            
                
                    
                        
                            The name for the current attribute. This name should
                            be same as specified in GBeanInfo for this GBean.
                        
                    
                
                
                    
                        
                            The type of the current attribute. Again this should
                            be same as one provided in GBeanInfo hence optional.
                        
                    
                
            
        
    

    
        
            
        
        
            
                
                    The name for the current attribute. This name should be same
                    as specified in GBeanInfo for this GBean.
                
            
        
    

    
        
            
                
                    
                        The pattern used for matching the referenced GBean.
                    
                
            
        
        
            
                
                    The name for the current reference. This name should be same
                    as specified in GBeanInfo for this GBean.
                
            
        
    

    
        
            
                This group contains the components of an abstract name
            
        
        
            
                
                    
                        
                            The name for group containing module to match. By
                            default is it considered wild card '*'.
                        
                    
                
                
                    
                        
                            The name for module in a specified group to be
                            matched.
                        
                    
                
                
                    
                        
                            The version number for the module formatted by dot
                            separated numbers. If no version is provided it will
                            be defaulted latest available version matching other
                            criterions.
                        
                    
                
                
                    
                        
                            The value specified here should match the file name
                            of the module referenced.
                        
                    
                
                
                    
                        
                            This element defines the type of the module to be
                            matched. The type could be 'CAR', 'JAR', EAR',
                            'WAR', etc. If no type is provided it will be
                            defaulted wild card char '*'.
                        
                    
                
                
                    
                        
                            The name element to identify the referenced GBean by
                            name.
                        
                    
                
            
        
    

    
        
            
                
                    
                        referenceType includes all the elements defined in
                        patternType.
                    
                
                
                    
                        
                            The name for the current reference. This name should
                            be same as specified in GBeanInfo for this GBean.
                        
                    
                
            
        
    

    
    
    
    
    
    






© 2015 - 2025 Weber Informatics LLC | Privacy Policy