I would like to have additional fields in Jenkins that would be useful for reporting, for instance team names assigned to the automated tests, so that each team can clearly see their own tests.
Is it possible to add new custom fields to Jenkins reports and if so how can the field values be filled?
edit: Cut question down to make it more specific
There are no answers for this that do not involve nasty workarounds.
Instead, I will a feature request was submitted to the Jenkins project.
(updates here if and when the feature is released)
I had similar problem, and didn't find any straight forward solution. my workaround is to add it to std-out of the test, then it is possible to see it in jenkins later.
Related
It is very easy to create tickets on JIRA with almost no restrictions - which is why I am wondering if it is possible to force some kind of template or other limitation so that people create tickets with required fields.
I am unaware if this is possible and Google doesn't bring up much
The easy answer is yes, but there is a lot involved in creating custom request views that require admin access. You may find the following information helpful...
https://confluence.atlassian.com/doc/create-a-template-296093779.html
Field Configurations (which are applied through a Field Configuration Scheme) allow you to make specific fields required for a given Issue Type in a given Project.
See: https://confluence.atlassian.com/adminjiracloud/changing-a-field-configuration-844500798.html
You can do this type of restrictions and also change the aspect of the screen the users interacts with by using the Script Runner plugin, in particular by using the Behaviours feature of such plugin. You can also write Groovy code to customize almost every aspect of the form and do input validation/templating.
I was hoping to be able to set up Jenkins to have some sort of grouping for jobs for controlling permissions. As far as I can tell, a job is equivalent to a project, is that correct? I'm using Active Directory authentication along with Project-based Matrix Authorization Strategy. Is it possible (with any plug-ins) to have groups of jobs? Not asking about views or other GUI features (How to group jobs in Jenkins?). Pointers to relevant documentation would be appreciated. Thanks in advance.
I think the Role Strategy Plugin might do what you're looking for: with it you can define global or project roles, and control various permissions for each. Then you can assign roles to users (or groups of users).
To define project roles for a group of projects, the plugin can use pattern matching, so if you are consistently naming projects (jobs) you can easily define a group e.g. like: [projectname]-.* (matching each job that starts with the project name and a hyphen).
Using the answer above, and using the Role Base Plugin you can achieve that. The way to do it is to use parenthesis when defining the pattern. Say you have 2 jobs "Android Calculator" and a "iOS Checklist". And you want one role with access to both jobs. Since the names of the jobs are nothing alike using a pattern would be rather difficult. The plugin allows you to group them like listed bellow in pattern. Enjoy(Spent an afternoon looking for this answer):
(Android Calculator|iOS Checklist)
Found my solution here: https://www.intropro.com/resources/blog/57-jenkins-configuration-how-to under the Jobs Naming Pattern section.
I have installed jclouds and I am trying to learn how it works internally.
I read all the documentation on the site and on the github but still I have lot of questions about the architecture and implementation of the jClouds.
Do you know where I can find documentation about the deep technical implementation of the framework? I am also looking information on how to add a new provider( for blobstore service)
Currently I am looking into the code but it s not always straightforward what the code does.
The best thing to do is send an email to our dev list. You can subscribe by emailing jclouds-dev-subscribe#apache.org. You can also find us on IRC at #jclouds on freenode.
Adding a new provider is quite an important change for jclouds. The first thing you'll want to do is review How To Contribute. We need to make sure it will work properly and we'll be able to properly test it so don't be discouraged by the reviews.
Having said this, a number of general considerations to take into account when starting a new provider:
New providers are added in labs first, until they are stable.
To follow the jclouds style, use a 3 space indent and a 120 character line length.
We use Guava as our core library. Try to use its utilities before adding new dependencies. In general, do not add dependencies before consulting our dev# list.
We require both live and mock tests. "mock" tests verify that the api generates the expected request according to the method annotations, and that the response is properly parsed. We use MockWebServer to do that, and you can take a look at the MockTests classes in the openstack-swift api to see an example of how these tests work.
Often the best thing to do is to copy the entire directory structure of one of the existing apis or providers and delete everything that you don't need but keep some of the files around in each directory to server as an example of how to do things. You can rename those classes and start your work from there.
Which api or provider should you choose to use as an example for your work? It depends! Please email us on our dev# list to describe the work your doing and we will recommend one. The earlier you get engaged with the jclouds community, the easier the whole process will be.
Good luck!
We want to start letting our users help us test our feature changes before a wider release. Our rails app already has roles but I don't know how to we should go about implementing a beta feature without moving the whole app over.
Some issues I can't think of solutions to:
A beta feature may require a database migration. How can you handle this when it could cause problems with the existing app?
Changing templates and the css/sass will likely change it for existing features too.
Changing the underlying model code could break existing controllers / interfaces that rely on it.
One solution (a bad option) is to code in the new feature and wrap it in logic that only shows/uses it if the user has the "beta" role. The problem with this is when you finally take it live, you could have a lot of unwinding/changing to do. This is both a waste of time and could introduce bugs.
Another solution is to run a separate "beta" branch of the app off a subdomain and route users with the beta role to it. The problem with this is that the complexity of ssl certificates, email links and other domain dependent issues make this a bit of a maintenance pain (though not as bad as the first solution).
How can I offer this most efficiently so as to minimize the additional work to maintain and then switch the beta to the full version?
I think the only reasonable chance of these kind of tests work without affecting the current application would be using a "staging" environment and really just redirect the beta users to that environment.
Compared to problems with domain related features it is really nothing compared to migrations/functionality problems.
On our company we do exactly that, but we don't have the beta users thing, but without an separated environment it will be pretty much inviable to keep new features from messing with current features.
For the features, just use different branches for those new features and create that "staging" environment from that branch, once the features have been tested you just merge them to HEAD and new feature is there :]
One possibility to consider: making destructive (i.e. one-way, non-reversible) changes to your model may be problematic for reasons beyond inhibiting your ability to provide this beta functionality. For example, it may difficult to backout from a change if you have a problem during the migration.
Instead, I would recommend looking at ways to only add to the model: add columns while leaving old columns in place for backward compatibility, version stored procedures if you're using them, etc. If you need to alter column data types, instead create a new column of the target data type, then have your migration also copy existing rows data from the old column to the new column in the new format. You can then perform your database migration in your test environment and confirm that both the old and new versions of the application continue to work with the database changes.
One potential way to serve up multiple versions of your application is to use an alternative respond_to format for your beta site. You could create a method in your ApplicationController to check if the user was in the beta. If true, you can override the request.format value and in your respond_to block have a "format.beta" type response.
The challenge with this approach is the controller logic. Without embedding some kind of switching logic within your controller methods, you won't have a way of altering the controller code path. This may not be a major problem, depending on how many controller changes you have.
(By the way, it looks like we have very similar names! :-) )
What I can think of is something like having a user_type column in your users table. so that you can flag them as beta users. (Even you can set this flag as default so that you dont need to change the existing code. All the new users who are creating will be beta users.)
For this i'm assuming
You are giving all the features to your beta users
Beta users will be having the same functionality which will be having by normal user in future.
** Only advantage is that you can filter beta users as and when they are login. Upon that you can do something like allowing to login or not etc..
When you are switching to the full version just update beta users as normal users
I dont know how this is applicable to your scenario.
thanks
sameera
I personally don't think it's a bad idea to wrap the code with a check for a user having the beta role. It will be quite easy to search for all of the calls to, for example if current_user.authorized?(:beta) and the remove them entirely.
One thing I am thinking about doing is setting up a beta "staging" environment that is actually the production environment. The idea would be to have beta.mydomain.com and then send users there that want to get features early. Basically, it would just be a branch that gets deployed to the beta site which is live.
I have been using Jira since 6months but haven;t been through any document related to various options available and how to use them for maximum output.
There must be some conventions that help in better tracking of the issue.
For instance, Logging work, Linking issues, creating sub-tasks.
It would be of help if you can share some of the features (and the conventions) that you follow while using Jira. It may vary from team-to-team but there must be some generic rules which can be followed.
Any feedback would be of help. Thanks.
Some of our conventions for using JIRA:
Each project has its own JIRA project.
We use the Greenhopper plugin for Scrum planning.
There is no development without a JIRA issue assigned. If needed, Developer add issues on their own.
Commits contain the JIRA ID (for FishEye integration).
Language of JIRA comments.
When working on an issue, it's state is changed to "in progress"
Findings, Problems, Things Done are documented as comments.
Related answer here.