6 Replies Latest reply on May 18, 2010 3:41 PM by Nick Belaevski

    Distributions/Release Artifacts for Alpha2

    Jay Balunas Master
      For 4.0 Alpha2 we have an updated build, and module structure.  Part of the reason for this was to make it easier to develop, release, and build distributions for 4.0.
      Note: Distribution == release artifact like .zip files
      Note: these are just my proposed layouts, please comment, and we'll finalize at tomorrows team meeting.
      Take a look http://community.jboss.org/wiki/RichFaces40BuildDirectoryStructure for the build structure that we are working on completing now.
      In this structure we have various modules that need to be combined and built into our release artifacts.  Single module artifact assembly can be handled by the modules aggregator.  However there are times when multiple modules are required in a single release artifact.  This is handled by the various /dist modules, these are responsible for packaging their sibling into a consumable release artifact.  The root /dist is responsible for putting all of these things together into our top level release artifacts.

      General Comments

      • The creation of these artifacts are separate from the release plugin and releasing the project
        • Once setup of these artifacts are complete we need to create these artifacts nightly in hudson
        • Releasing ( tagging, update versions, etc… ) will be the next topic discussed.
      • Every jar should have its source, and javadoc jar with it. 
        • Other generated docs should be in /docs along with javadocs I think
      • Example: I like the way Weld artifacts are structures - http://seamframework.org/Weld/Downloads

       

      /weld-1.0.1-Final
         /artifacts
            /cdi
               cdi-api.jar (and source/javadoc jars)
            /weld
               weld-*.jar (and source/javadoc jars)
         /docs
            /apidocs
            /en-US
         /examples
            /<example>
            /<example>
            readme.txt
            build.xml
         license.txt
         readme.txt
         release-notes.txt
      

      General Questions

      • Source code in separate package or combined?
        • I think combined is best ( and buildable )
      • Single large richfaces-4.0.0.Alpha2 artifact or have them be separate ( main, examples, docs, etc…)?
        • I believe a single artifact is best.
        • If examples become too large we can separate

      Artifact Structure/Comments

      CDK
      Name: richfaces-cdk-4.0.0.Alpha2
      Alex is going to be constructing a separate richfaces-cdk-4.0.0.Alpha2 artifact.  As we have discussed it will have documentation ( guide, javadocs, schema docs, etc…), binaries, sources, etc…  This will be its own download.
      Alex please provide some idea's for your structure of that.
      UI/Dist
      The ui /dist is going to be responsible for calling the UI modules and asking them to assemble themselves, then combining into a single artifact.  This will require something like the maven shade plugin.
      The outcome of this will be several jar files ( api, impl, ui ) that can then be packaged by the root assembler into the final dist.
      Open Question: Do we also package the individual module artifacts, or only the combined.
      Examples
      Name: richfaces-examples-4.0.0.Alpha2
      The example/dist will call the assembler of each of the example modules and then package their distribution into single artifacts.  Then depending on the answer to the question above about single or multiple artifacts will either be packaged into the main dist, or simply be packaged into its own zip.
      /examples
         /<example 1>
         /<example 2>
         readme.txt
         build.xml ( maybe someday )
      

       

      Each example should have a pre-built version, and the source code to rebuild the example.

      Archetypes
      These have there own packaging, and I do not think require their own release artifact, but still need to be packaged by the archetyle/dist into a directory or structure that can be consumed by the root dist.
      /archetypes
         /<archetype 1>
         /<archetype 2>
         readme.txt
      
      Root Dist
      Name: richfaces-4.0.0.Alpha2
      The root dist will be responsible for packaging the main richfaces distribution.  This will either call the assembler/aggregator of single child modules, or the /dist builds from multiple module builds discussed above.

       

      /archetypes
         /<archetype 1>
         /<archetype 2>   
         readme.txt
      /artifacts
         /framework ( or core not sure )
            richfaces-core-api.jar (and source/javadoc jars)
            richfaces-core-impl.jar (and source/javadoc jars)
            richfaces-commons-api.jar (and source/javadoc jars)
         /ui
            richfaces-ui.jar (and source/javadoc jars)
            /<module> ( if we break it down )
      /docs
         /apidocs
         /<other sean docs>
      /examples ( if we combine )
         /<example 1>
         /<example 2>
         readme.txt
      lgpl.txt
      eula.txt
      readme.txt
      release-notes.txt
      

       

      Version #s are on the various jar files above

        • 1. Re: Distributions/Release Artifacts for Alpha2
          Nick Belaevski Master

          Once setup of these artifacts are complete we need to create these artifacts nightly in hudson

          Can you please clarify what artifacts do you mean? I know that in the past artifacts occupied plenty of server space, so we've switched them off for nightly builds.

          Every jar should have its source, and javadoc jar with it.

          I've asked Alex about JSDocs support in IDE, he answered that they are supported. So we should package them also.

          Source code in separate package or combined?

          Can you please give examples for both, so we are on the same page?

          What artifacts should be buildable: examples or core/ui modules also?

          Single large richfaces-4.0.0.Alpha2 artifact or have them be separate ( main, examples, docs, etc…)?
          • I believe a single artifact is best.
          • If examples become too large we can separate

          Agree for both points.

          Open Question: Do we also package the individual module artifacts, or only the combined.

          My opinion is that we don't need individual artifacts right now, but they can appear in the future - e.g. for sandbox, extension, etc. components.

           

          Other things look good, no comments.

          • 2. Re: Distributions/Release Artifacts for Alpha2
            Jay Balunas Master

            Nick Belaevski wrote:

             

            Once setup of these artifacts are complete we need to create these artifacts nightly in hudson

            Can you please clarify what artifacts do you mean? I know that in the past artifacts occupied plenty of server space, so we've switched them off for nightly builds.

            Ideally I would like to have nightly artifacts build.  If for no other reason to verify that changes to the project do break the assembly.  I think that is important to the time-box releases.  I think we would need a separate nightly build for this, that would only keep 1-2 archived builds.  Ideally it would be good to get those uploaded to our nightly download locations.

             

            Nick Belaevski wrote:

            Every jar should have its source, and javadoc jar with it.

            I've asked Alex about JSDocs support in IDE, he answered that they are supported. So we should package them also.

            That would be good if it is possible, but I would want that to be a lower priority.  The assembly, release, and structure updates are top priority.

             

            Nick Belaevski wrote:

            Source code in separate package or combined?

            Can you please give examples for both, so we are on the same page?

            What artifacts should be buildable: examples or core/ui modules also?

            Older Seam distribution used to have a src directory that could be built easily by the user.  This made it easy for people to see try out changes, and I think encouraged people to get involved.

             

            BTW - the examples for sure should be buildable, and contain all of the src.  This is very important to people to integrate into their IDE, and really understand how things work.  When you just provide a war, it is a little too abstract I think.

             

            The exact way the source would be included is not 100% clear in my mind.  But we would have requirements like maven, jdk, etc... to be installed.

             

             

            /artifacts
               /framwork
                  /src ( to rebuild core & commons )
               /ui
                  /src ( to contain basically everything under /ui in svn )
            /examples
               /<example 1>
                  /src ( to rebuild example 1 )
            

             

            Or maybe just a base directory /src for everything?  These are the things I want to discuss.

             

            more to come....

            • 3. Re: Distributions/Release Artifacts for Alpha2
              Jay Balunas Master

              Nick Belaevski wrote:

              Single large richfaces-4.0.0.Alpha2 artifact or have them be separate ( main, examples, docs, etc…)?
              • I believe a single artifact is best.
              • If examples become too large we can separate

              Agree for both points.

              ok good - I think we should just go with this then.

              Open Question: Do we also package the individual module artifacts, or only the combined.

              My opinion is that we don't need individual artifacts right now, but they can appear in the future - e.g. for sandbox, extension, etc. components.

              Agree - lets hold off for now.

              • 4. Re: Distributions/Release Artifacts for Alpha2
                Ilya Shaikovsky Master

                A little clarification about sources.. does the artifacts which generated by CDK will be also there or the developer will use CDK to build from sources?

                 

                In general looks good for me also - I also really like seam distribution which includes sources docs and examples - so you could easilly play with all that stuff after downloading single distribution.

                • 5. Re: Distributions/Release Artifacts for Alpha2
                  Jay Balunas Master

                  Ilya Shaikovsky wrote:

                   

                  A little clarification about sources.. does the artifacts which generated by CDK will be also there or the developer will use CDK to build from sources?

                  The proposed builds in the /src directories would be using maven ( little or no different then what is in svn ).  They would pull cdk as part of build.

                   

                  The cdk distribution would have its own source to build if users wanted to explore the cdk.

                  • 6. Re: Distributions/Release Artifacts for Alpha2
                    Nick Belaevski Master

                    Updates from meeting:

                     

                    1) User should be able to rebuild core, commons & ui from distribution archive (with no need for release distribution rebuild)

                    2) IDE import instructions are necessary