Similar to adding dependencies between User Stories, Is it possible to add dependencies between tasks within a story ?
Related
When I have to get the code from ALM, I create a new repository workspace and then create the sandbox.
Why there is a need to create repository workspace?
Why cant I directly take the code from stream?
Assuming you want to modify and check-in changes to these files...
The Jazz source control in RTC relies on the repository workspace to track your changes. This is your own private version of the stream on the Jazz server, and when you check-in your sandbox changes are pushed here from your Eclipse workspace.
As mentioned in "Working with repository workspaces"
A repository workspace is a private development area where you can keep your work and those contributions that are shared by your team members.
Your work is private to the workspace until you decide to deliver it to a team flow target such as a shared stream.
Setting up your repository workspaces with the proper contents and flow targets is the first step toward making your contributions to the team's efforts.
That is why there is an intermediate repo between the stream and your sandbox:
source: Lesson 6: Source control
You can read more about the "relationships between Streams, Repository Workspaces, Components and Sandboxes.":
A developer will deliver their changes to the flow targets defined for their Repository Workspace.
The corresponding action for a Snapshot is the promote operation. Another developer will accept those changes when they are ready too.
I have a build chain of 4 build configurations, which correspond to different teams' tasks. The idea behind the configurations is this:
Run the build itself
Move build to staging
QA approved
Release
Each of those configurations have different responsible people. People not responsible for a given configuration should not be allowed to run it.
I know I can define roles on project-level, but here I need to define it on a build configuration-level. Is that possible?
Thanks
You can create subprojects for each configuration and then assign roles corresponding to restrictions.
You can add precondition step to each job where check username and fail step and job if user not allowed to run this job.
I made the second approach in similar case.
Is it possible to configure a deployment project with optional 'Artifact Download' task?
The artifact comes from another plan which has 2 stages producing 2 artifacts. If only 1 stage is executed, it will have 1 shared artifact. I want my deployment project to run even there is only 1 artifact.
But bamboo fail the whole execution with error: "Unable to download artifact Shared artifact: ..." trying to locate the 2nd artifact.
How can I tell Bamboo to ignore the missing artifact and continue the execution?
The only way I've figure this out is to instead of name an artifact, put all of the artifacts into a "directory" as part of the build process, say "artifacts/", and define the artifacts as "artifacts/**". Then on the Deployment side, be clever about manipulating the artifacts for deployments.
Note, in my case, I have an issue with multiple branches for the same build (think, "future release", "current release", "legacy release") that may have different artifacts on them (either new features in "future release", or aged off artifacts from "legacy release"). I had to wrap the actual deployments into a script that was "smart enough" to just iterate through artifacts that actually existed for a given deployment environment.
I'm not completely happy with Bamboo's treatment of special cases for artifact management at all. In fact, I've found that judicious use of the "script" task in Bamboo (and managing those scripts in some external git repo) seems to be the only real way to manage larger Bamboo installations in general.
I'm having a tough time seeing the "forest through the trees" on some Maven concepts here. I understand that Maven comes preconfigured with a slew of so-called "Build Lifecycle Phases" that begin with validate, and test and end with deploy.
I am coming to Maven from Ant where you organized major build stages into targets (which can depend on other targets in a linear fashion), and then you decompose your targets into procedural tasks. Maven seems to supports this but in the form of goals.
My question (since I am used to thinking of building in terms of targets and tasks) is: how do these lifecycle phases (package, verify, etc.) relate to goals? Does one need to configured which goals to run at which phase, or is this done by Maven automagically somehow?
Or, do the goals come predefined with which phase they belong in?
I'm just not seeing how one orders goals to create a custom build that works for them or their organization.
Thanks in advance for any clarity!
Many Maven plugins bind specific goal(mojo) to a specific lifecycle phase.
E.g. look for documentation of maven-jar-plugin:jar goal. It says:
Binds by default to the lifecycle phase: package.
Also, lifecycle itself is specifying what tools need to be run for each phase. For default packaging types these tools are predefined by Maven and explained here -> http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html#Built-in_Lifecycle_Bindings.
But this example shows how to create totally custom lifecycle binding -> http://www.sonatype.com/people/2009/08/create-a-customized-build-process-in-maven/. As you can see you can bind any combination of plugin goals to a specific lifecycle phase.
Last, but not least, you can add plugin execution manually through the build/plugins element of your pom file. If you do that the plugins in specific phases will execute in a FIFO order.
Also, it may help you to see the Effective POM with all these defaults spelled out. Many IDE's offer this option for Maven projects, but you can also see effective pom from the command line:
mvn help:effective-pom
Maven has 3 lifecycles which are inturn executed in many phases (package, verify, etc). When these phases are executed, it calls the previous phases as well.
Goals are individual tasks. When it is called, that particular task is executed.
Check the below blog for more detailed explanation.
https://techytopics.wordpress.com/maven-simplified/
We have a project which should be buildable by the customer using maven. It has some open source dependencies that are mavenized (no problem), some that aren't mavenized, proprietary stuff (oracle jdbc driver) and some internal stuff.
Until now we had everything but the first category packaged with the project itself in a local repository (repository with file://path-in-project-folder specified in the projects pom.xml).
We would love to move these out of the project, as we are about to use them in other projects as well. Currently we plan to use nexus as an internal maven repository.
Whats the best practice to make such dependencies/maven repositories available to the customer so he can continue to build the project.
Ideas so far:
Customer sets up a nexus repository as well, we somehow deploy all these non-public dependencies to his repository (like a mirror)
We provide a 'dumb' dump/snapshot of the non-public dependencies, customer adds this snapshot to this settings.xml as a repository, (but how is this possible).
Make our internal nexus repo available to the customers build server (not an option in our case)
I'm wondering how others solve these problems.
Thank you!
Of course, hosting a repository of some kind is a straightforward option, as long as you can cover the uptime / bandwidth / authentication requirements.
If you're looking to ship physical artifacts, you'll find this pattern helpful: https://brettporter.wordpress.com/2009/06/10/a-maven-friendly-pattern-for-storing-dependencies-in-version-control/
That relies on the repository being created in source control - if you want a project to build a repository, consider something like: http://svn.apache.org/viewvc/incubator/npanday/trunk/dist/npanday-repository-builder/pom.xml?revision=1139488&view=markup (using the assembly plugin's capability to build a repository).
Basically, by building a repository you can ship that with the source code and use file:// to reference it from within the build.
There are two options:
Document exactly what artifacts you need to compile which are not
available via Maven Central
Implement Nexus and make a export with Nexus give the export
to customer and they need to do a import of it. I'm not sure
if you come to licenses issues.
I assumed that you already have a Repository Manager already but it reads like you didn't.