I'm new to makefiles and jenkins.Is there any guide on how to write makefile to run build and the unit test together using jenkins.?
You can definitely use Makefiles to build and run both your application/library and tests.
Here is a good guide to Makefiles:
http://mrbook.org/tutorials/make/
It should help you with writing a simple makefile. For more information, Google is your friend.
Another good guide is here:
http://www.cs.swarthmore.edu/~newhall/unixhelp/howto_makefiles.html
Remember, jenkins and makefiles are completely unrelated. You can use Jenkins with makefiles, and use makefiles without jenkins. One is a continuous integration system, the other just another way of building your software.
You can go ahead and use Xserver as suggested in the other post, but Jenkins has advantages that many other systems don't: it is extensible using a whole host of plugins, has a large user and developer community and is used for multiple types and styles of projects in various languages. While your project is purely for iOS, there are other things in Jenkins you could take advantage of from the available plugins list.
There is an XCode plugin:
https://wiki.jenkins-ci.org/display/JENKINS/Xcode+Plugin
Maybe this helps too:
http://programming.oreilly.com/2013/04/upward-mobility-automating-ios-builds-with-jenkins.html
But maybe you are better off using Xserver if you try to do continuos integration:
https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/xcode_guide-continuous_integration/200-Adopting_a_Continuous_Integration_Workflow/adopt_continuous_integration.html
Related
My former web developer setup my site so that it uses Jenkins and GitHub. I understand the very basics of GitHub and even less of Jenkins. But in theory, when I make minor text changes to my website, can't GitHub manage the process of pushing those changes to the server? Or is there some good reason that Jenkins is also involved?
Thank you.
Yes. It's not a must but using both Jenkins and Github will make your life easy. Github and Jenkins are two tools that help you to do different functions.
Github will mainly help you to manage your codebase, resolve conflicts, etc. So it will basically behave as a repository. You can commit your changes and get other's updates and always be up to date. There are tons of other advantages but I'll keep it simple for understanding purpose.
Jenkins is an open-source automation server. In your case, you can automate the product building. For example if you have a test environment or even when you deploy the changes t live, you can do all that with just a click. And you can separately build tests and live environments and With concepts like pipeline, you can even integrate the building with tests, etc.
But if you are talking about your local environment, yes git is enough because you can build the project manually. but in production have git and jenkins both will be a handy option.
Read more on Jenkins
Bazel is a multi-language build tool from Google that acts as a replacement for things like Maven, Gradle, Make, etc. There are articles written on how to migrate from Gradle to Bazel, for instance. But I wonder if this tool works with Grails.
Grails is a web app framework that uses Gradle, but from what I've seen it's a bit more than that. For lack of a better term, Grails itself acts as a "wrapper" for common tasks such as building an app as a WAR or JAR file, running the app locally with different profiles, or scaffolding new files and features. Popular IDEs such as IntelliJ have Grails plugins available to run these Grails commands. So it seems to me like it's perhaps tightly coupled to the Gradle build script that backs it.
It also seems to me that just because Bazel says it supports Gradle projects doesn't necessarily imply that it supports Grails projects, because of all these reasons regarding Grails being more than just Gradle. But I wanted to ask the community if my assumptions are true, or if, in fact, people are already using Bazel as a substitute for Gradle inside Grails projects. Can it be done?
Bazel could in theory be used to build grails projects as it is fundamentally agnostic to the type of thing being built. That said, grails probably works well with gradle out of the box and you'd have to re-implement a number of things yourself again and probably is not worth the effort. If you are a large shop and have multiple other languages that you need to support however, it may be worth investing in the effort.
https://github.com/pubref/rules_maven supports using a gradle file to determine transitive maven dependencies if you want to investigate further.
I want to integrate the web artifacts part of my application with brunch.io.Could not find some descent google search for the same.
Can anybody help out?
Use Maven-exec to run a shell script that runs your brunch build command.
Reviewing this article about maven/grunt integration will probably also be helpful, as the underlying concepts for running a Node.js tool from maven are basically the same.
Is it possible to use Buildr or Gradle to manage Erlang project deps and build/package the app itself?
I guess rebar is the closest thing to what you describe. It can be used to build and package Erlang applications, define pre-compile and post-compile operations and so on.
Are there any tools/ ant tasks that could be integrated into the ant build file to build Symbian applications? Similar to what we have for Android (AndroidAnt), BlackBerry (BB Ant Tools), .NET (Nant)
There isn't any officially supported stuff as far as I know, but (having done it myself) I know it is perfectly possible to build Symbian apps using Ant by simply calling the command line tools from ant commands.
If this is a precursor to automatically building symbian apps using a build server of some description, remember that Symbian builds have an annoying habit of polluting the build environment so you will need to invest some time into automated environment cleaning and environment setup.
This article is a good starting point: Continuous integration on Symbian OS
However, it doesn't cover the 'polluting the build environment' problem, which is an important one. In-house, we have fully automated Symbian builds using ANT and Cruisecontrol. We get around this problem by deleting/expanding the entire epoc32 tree with each build. This approach is fool-proof, but makes the builds very time consuming, which kills some of the benefits of continuous integration....
Actually Helium is the name of a Ant based build framework available through the Symbian foundation (http://developer.symbian.org/wiki/index.php/Helium).
It contains Ant build scripts and Symbian dedicated tasks (but not only, there are also general features...).
Developer.symbian.com and symbian.org links doesn't work anymore.
But mentioned continuous integration tutorial is available inside Symbianosunit package by Penrillian