Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 4 years ago.
Improve this question
We currently have Java program which runs a multitude of tasks on our Windows servers, we are planning to replace that with an open source task automation software for efficiency and maintainability reasons.
The following are the features we are looking for:
Ability to run tasks/scripts in any language (Java, C#, Python etc..)
Schedule the tasks at any instant (12:00 AM 12/16/2010) or run them at specific intervals (Every 10 minutes).
Ability to notify the admin if a task execution failed and preventing them to run again.
Parallel execution of independent tasks and ability to set dependencies between tasks.
Ability to priortize and preempt the tasks when needed without restarting the software.
Reporting capabilities on how long each task took etc.
Remotely adding, deleting and monitoring the progress of tasks which are being executed
Please let me know if you know of any great open source solutions which address all or most of these needs. Thanks for your help!
You can try using Hudson, the opensource Continuous Integration system for doing this. It provides most if not all of the features you are asking for. Each task (or call it "project" in the Hudson lingo) can be scheduled periodically, or via a SCM trigger, or a curl call using the tokenizer URL. You can interlink jobs as downstream projects, and can also execute them parallelly among various boxes. It has great error reporting capabilities, and archives all the build logs, error reports and supports various formats like junit to generate you colorful plots showing the trends of your job success rate, test metrics etc.
Refer this to get started off:
http://wiki.hudson-ci.org/display/HUDSON/Use+Hudson
You can schedule the tasks by creating them as Maven targets (or ant, Makefiles anything for that reason; it can run any script so it is quite flexible) The email notification is quite useful to notify is the jobs are failing or unstable.
Moreover, Hudson comes with a bunch of opensource plugins, and is very useful. Hope that helps.
Have you considered Quartz.Net ?
Some highlighted features below.
Job scheduling
at a certain time of day (to the millisecond)
on certain days of the week
on certain days of the month
on certain days of the year
not on certain days listed within a registered Calendar (such as business holidays)
repeated a specific number of times
repeated until a specific time/date
repeated indefinitely
repeated with a delay interval
Clustering
Fail-over.
Load balancing.
Listeners & Plug-Ins
The Plug-In mechanism can be used add functionality to Quartz, such keeping a history of job executions, or loading job and trigger definitions from a file.
Quartz ships with a number of "factory built" plug-ins and listeners.
Although support for Windows is still experimental or under progress, you can look into:
Puppet
http://projects.puppetlabs.com/projects/1/wiki/Puppet_Windows
and
Chef
http://wiki.opscode.com/display/chef/Installation+on+Windows
http://support.rightscale.com/12-Guides/Windows_User_Guide5_Configuring_Windows_Servers/Using_Chef_on_Windows
Have you researched PowerShell? It has the ability to call .net libraries, any type of executable and any type of script.
You can script complex workflows with parallel tasks and sequential tasks.
You can write to the Windows Log, send email notifications, write logs in a variety of formats, etc.
If you run the scripts from Task Manager, you can remotely start, monitor and stop any task.
It's free.
Related
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 3 years ago.
Improve this question
I'd be really happy if you could just make me understand this easy topic.
I know what jenkins is and what it does. Let's now make the comparison.
We use jenkins so that as soon as code gets pushed to repository, by git hooks, we run jenkins job which pull that code, make the build, run tests, and then if needed, upload it to remote machine where the code actually runs.
Now, what I can do instead is when git hook happens, I will run the bash script and that bash script will do the things(like pulling code from repository, running build, making test and then uploading it to remote machine via ssh).
So,I can do the same thing via bash script.
Question is : I don't see that much big of advantage.
So,could you do your best and explain in very simple terms why this has a big advantage ? I know there are many plugins for Jenkins, but this is not the way to make the comparison best way.
This explains the why we should avoid scripts and look for tooling. Moreover Jenkins and similar tooling provides standard ways to handle such deployments problems.
When development begins on a new software project, it is often a popular choice to script many of the steps of the continuous integration (CI) process. As the project grows to require a more complex infrastructure, unit and end-to-end testing, and a robust, repeatable deployment procedure, simple scripts are no longer the best solution.
To save a large hit on productivity, a better alternative is to replace these scripts with a Jenkins build server and a pipeline onfiguration.
When it’s Time to Replace Scripts
There are a few obvious signs that it might be time to replace scripted deployment methods with something a little more robust.
When It Doesn’t Scale: For every new piece added to an application, the scripts have to be updated. Whether you’re using bash, python, or something else, this can get out of hand quickly. Every line of code added to put new files in different locations, update permissions, and restart processes create more complexity and a greater risk of something going wrong.
When It Becomes Unmaintainable: The increasing complexity, from things like the addition of conditional logic to alter the deployment based on the state of the system, inevitably leads to a set of scripts that only a handful of developers can interpret. A process like this that grows organically to quickly meet the immediate needs of deploying the application creates a big problem.
When It Gets Expensive: In this case, the expense comes in the form of developer hours and productivity. The overhead required by the manual processes involved in preparing for and executing a release will begin to have a significant negative impact on new feature development.
Source:https://www.bandwidth.com/blog/replacing-scripted-software-deployments-jenkins-pipeline/
Jenkins probably works best when the project is structured along standard lines (as the most vanilla example take a Makefile/gcc project on Linux with a git repo).
For such a project Jenkins can be set up with a few steps to automatically check out, build, test and document these tests. A DIY approach would just re-invent the wheel.
If, on the other hand, the project has lots of unusual tools, mixes cygwin/POSIX things with Windows tools and relies on a lot of legacy scripting to glue things together the Jenkins workflow must be customized. Significant groovy code has to be maintained to call the idiosyncratic mix of bash, perl, and cmd scripts, some with Windows and some with POSIX command line syntax, strip away carriage returns from ClearCase outputs, move tool artifacts around and what not. That could perhaps be done as well with manual scripting. Jenkins still has an edge here though from the user perspective because of its built-in web interface. For example it provides forms to parametrize builds and provides a graphical overview of scheduled, running or finished jobs with links.
There may be another advantage to Jenkins when it comes to distributing the workload to several machines for which Jenkins has built-in support.
I'm looking for some comparison between Quartz.NET and Windows Scheduled Tasks?
How different are they? What are the pros and cons of each one? How do I choose which one to use?
TIA,
With Quartz.NET I could contrast some of the earlier points:
Code to write - You can express your intent in .NET language, write unit tests and debug the logic
Integration with event log, you have Common.Logging that allows to write even to db..
Robust and reliable too
Even richer API
It's mostly a question about what you need. Windows Scheduled tasks might give you all you need. But if you need clustering (distributed workers), fine-grained control over triggering or misfire handling rules, you might like to check what Quartz.NET has to offer on these areas.
Take the simplest that fills your requirements, but abstract enough to allow change.
My gut reaction would be to try and get the integral WinScheduler to work with your needs first before installing yet another scheduler - reasoning:
no installation required - installed and enabled by default
no code to write - jobs expressed as metadata
integration with event log etc.
robust and reliable - good enough for MSFT, Google etc.
reasonably rich API - create jobs, check status etc.
integrated with remote management tools
security integration - run jobs in different credentials
monitoring tooling
Then reach for Quartz if it doesn't meet your needs. Quartz certainly has many of these features too, but resist adding yet another service to own and manage if you can.
One important distinction, for me, that is not included in the other answers is what gets executed by the scheduler.
Windows Task Scheduler can only run executable programs and scripts. The code written for use within Quartz can directly interact with your project's .NET components.
With Task Scheduler, you'll have to write a shell executable or script. Inside of that shell, you can interact with your project's components. While writing this shell code is not a difficult process, you do have to consider deploying the extra files.
If you anticipate adding more scheduled tasks over the lifetime of the project, you may end up needing to create additional executable shells or script files, which requires updates to the deployment process. With Quartz, you don't need these files, which reduces the total effort needed to create and deploy additional tasks.
Unfortunately, Quartz.NET job assemblies can't be updated without restarting the process/host/service. That's a pretty big one for some folks (including myself).
It's entirely possible to build a framework for jobs running under Task Scheduler. MEF-based assemblies can be called by a single console app, with everything managed via a configuration UI. Here's a popular managed wrapper:
https://github.com/dahall/taskscheduler
https://www.nuget.org/packages/TaskScheduler
I did enjoy my brief time of working with Quart.NET, but the restart requirement was too big a problem to overcome. Marko has done a great job with it over the years, and he's always been helpful and responsive. Perhaps someday the project will get multiple AppDomain support, which would address this. (That said, it promises to be a lot of work. Kudos to he and his contributors if they decide to take it on.)
To paraphrase Marko, if you need:
Clustering (distributed workers)
Fine-grained control over triggering or misfire handling rules
...then Quartz.NET will be your requirement.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 8 years ago.
Improve this question
So, a little background. We are a small company with a half-dozen developers. We have been evaluating many project management / issue tracking software packages (TRAC, Redmine, FogBugz, etc) and trying to create a decent process/workflow for managing projects, adding features, fixing bugs, etc. I'd like to think our requirements are similar to most other companies our size.
Essentially, what this comes down to is
1) An easy way for the PM and developers to track projects, issues, bugs, etc
2) An easy way for the PM and admin/executives to get a birds-eye view of progress and easily manage timelines, schedules, and priorities.
After trying TRAC, we moved to Redmine. We found Redmine to be easier than track to administer and the ability to have sub-projects and sub-tickets is great.
However, the big problem we ran into is the fact that it is very difficult to manage schedules and timelines. It seems like it would be incredibly time-intensive to manage because you have to manually enter a start date, estimated time, and end date for each ticket, project, etc.
So if you setup a month's schedule based on priorities, what are you supposed to do when a particular ticket/issue/subproject takes up more time than was estimated. Right now, it appears I would have to go back in and MANUALLY change the start/end date of every single item.
What would be ideal is to be able to set priorities/dependencies and estimated time on tickets/milestones, and have the software automatically manage the start/end dates. Does anyone know how to get Redmine to do this, or recommend a different software package that can do something like this!
From what I understand you need more than a issue tracking system. More exactly you need to also have a task scheduling mechanism. I do not know a issue tracker with task scheduling engine. I guess that with this feature you are entering somehow in the project management area so I would recommend a project management tool.
I think MS Project (as Kalven said) is too much for you. Try a simpler alternative like RationalPlan first.
If you use the "schedules" plugin (not sure if it's compatible with Redmine 1.1.0) you can set it up so that you can automatically set the start and end dates of issues. I'm not certain that it takes issue relations into account though, but if it does, it should be enough to just change the estimated time for an issue that is taking longer than you first thought and then refill the calendar/schedules.
I have also used many project management software for my small business. However, from last 8 months I am using Project Professional 2010 which is helping me a lot in project task management and time management. I will recommend you to opt for the same.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 3 years ago.
Improve this question
We need to compile our code after check - ins, be notified if compile fails, run tests, be notified of test results and publish our application (publish a website or create an msi file for a desktop app) on a daily basis.
We are using SVN and were considering using TeamCity or CruiseControl.NET for continuous integration server for our .net projects which have msunit tests.
My project manager came up with HP Quality Center and Quick Test Professional (it is already purchased) and suggested using them for issue tracking (currently we are using Jira) and continuous integration.
Does it make sense?
NO. I'm using now at a client, and hate it. It does not support non-MS browsers (ActiveX, etc), so on OS X, we are stuck with VMs, etc. Moreover the interface it quite clunky & slow. It's ancient, horrible, legacy tech. There are much better options.
We have lots of customers who integrate QC defect and test tracking into pipelined continuous integration. But QC is not driving the process, it's being integrated into the CI and CID process.
We use QC to run what are called Test Sets. We have been very successful running in this manner. You can use QC to notify you on a failed execution. This would of course notify you if something did not compile on QTP's end. You also set up other QTP and LoadRunner scripts to run if a script fails.
Not a good idea, I've done a POC for QC and Borland tools (for HP), and although possible, there are too many area where the synchronization has to be perfect, and the slow response time of QC sometime due to network etc to trigger right file, get result of compilation and publish is a bit shaky. Again technically via API it is completely feasible.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 5 years ago.
Improve this question
Does anyone have recommendations for a good task/time management tool.
Ideally this would just keep track of programming tasks / the project and the time spent also the option to produce an end of week report would be advantageous
at the lower end, for free software, there's ToDoList
FogBugz is your friend too. FB6 is a great PM tacking tool, I've been using 5 to manage my team and I'm trying to pry the money for FB 6 out of those that hold the purse strings.
For open source/ 1 dev its free as well.
A good tool with collaboration feature as well:
http://www.producteev.com/
We have been using Eylean for our project management. It has all the features you are looking for and then some. You will be able to visualize your tasks as post it notes on a task board, estimate how much time they will take and then track them in order to see how much time they actually take up. It might be little more than what you are looking for, but i really enjoy the software.
JIRA has a log work feature. You log your work on a per task/issue bases. My boss rather likes the reports.
If you work with a large team, Team Foundation has it all. Work item tracking (which can be tied to checkins and builds!), reports, all sorts of metrics. For a small organization though the cost is probably too high.
Voo2do is pretty good. I've used it before and it's great because it's very simple to start, but you can use the extended functionality as needed. And there's an API, which can fill in the missing features.
organize tasks by project
track time spent and remaining
add tasks by email
publish task lists
as easy as paper, but on the web 24x7
supports software guru Joel Spolsky's Painless Software Scheduling method
fancy-shmancy “ajax” interface
API for custom applications
For basic commandline task tracking I use http://wtime.sourceforge.net/ It's simple but effective but only has top level tasks.
Here's another vote for FogBugz. Originally I bought it for managing client projects, but I've grown to use it for keeping track of almost everything to-do related in my life -- simple tasks, stuff to remember, small personal/home projects, books to read, etc. It's feature-rich and has a handful of nice integration points, and while it's still very much software-type-task-oriented, it's handy. Very reasonably priced for the value.
For task management for myself - Outlook
It's centralised
I have to have my email open so I don't need to worry about yet another application
Sync to server so I can get it anywhere I have a browser
Sync to phone so I get reminders when not at the desk
Emails can be flagged as tasks
For task management for a team - TFS 2008 with SP 1. There is some nice enhancements in there with alerting that makes a big difference.
We use Smartsheet as a tasking and collaboration tool. It's pretty well based on the idea of a spreadsheet that you can add your own columns to. The sheets can be shared amongst team members, it sends you emails when anything changes, it has file share (without limit) - you can also give external people access so that they can raise bug notifications etc. that then get notified to the team. Works very well for us as it is SO flexible
I recommend Task Coach, an open source, single person, hierarchical task manager that allows for time tracking, categories, reminders and much more.