I have several plugins and would like to create a nice update site to provide them. Some of them only contain core functionality (would not do anything, let's call them core-plugin) and others provide some functionality to the end user (they are dependent on the core plugins, let's call them useme-plugin).
now, I've created features for every useme-plugin. I included the corresponding plugin and set all dependencies (core-plugins).
these features, I've added to an update site.
When I try to install them now, I get complains that core-plugins are missing:
Cannot complete the install because one or more required items could not be found.
Software being installed: Useme-plugin 1.1.0.201108090928 (de.xxx.feature.feature.group 1.1.0.201108090928)
Missing requirement: Useme-plugin 1.1.0.201108090928 (de.xxx.feature.feature.group 1.1.0.201108090928) requires 'de.xxx.coreplugin 1.1.0' but it could not be found
Did I do anything wrong? I don't want to include the core-plugins into every useme-feature... Or do I have to do that? Can anybody help me to structure it correctly?
Features are ment to group related plug-ins that should be installed as a single unit on a target system. Thus you normally have a number of features for a non-trivial application:
the main feature with the base functionality of the application
a number of features for optional add-in functionality
a number of features with core functionality
a number of features with major collections of 3rd party plug-ins
Two or more features can include the same plug-in - the plug-in will still only exist in one instance on the target system. In special cases, several different versions of the same plug-in can even exist on the target system. In other cases where different features depends on different versions of the same plug-in, you have a conflict that must be resolved by the developer.
A feature can also include or depend other features, in which case, the depended-on features must be installed as well on the target system. Thus the main application feature depends on the needed core and 3rd party features and likewise for 3rd party features. The installation of the depended-on features usually happens automatically with p2. p2 is smart enough to only downloaded needed plug-ins when installing or updating...
At run-time, it does not matter how a specific plug-in ended up on the target system, which gives a number of options in your case.
When dividing plug-ins into features, you must primary consider the wanted applications on the target system and the wanted add-ins. It only gets really difficult when you have multiple applications or add-in that each use a sub-set of the core plug-ins or 3rd plug-ins.
You have not written whether you have a single application or a number of applications, so I assume you have a single application - it is rather easy to extend the idea to multiple applications that share a common set of plug-ins.
You can solve this problem in several different ways. The absolutely most simple solution is to make a single application feature and include the UI, core and 3rd party plug-ins in this - more or less as you suggest. This works fine if you just have a single product and don't expect to use the core plug-ins in other setups.
Often you divide your features to have core and UI features. Most often because the UI functionality is divided into different features to allow the end-user only to install the needed functionality.
So in you case, you can also have two features: the core feature and the application feature, which then depends on the core feature.
Or you can have
the core feature
a UI functionality feature - that depends on the core feature
an RCP feature (from Eclipse)
and main application feature that depends on all the other features
There are plenty of ways to do this...
Related
Company has projects each of which have their own accounts, opportunities and contacts.
Each project is self contained. So if I'm working in project (A), I don't need to see any elements from project (B).
I'm not sure how to achieve this. Separate sugarCRM install per project?
If they are completely self-contained, and the number of projects will not change frequently then two separate instanced could indeed make sense, especially if the projects will need different CRM customizations and have different users. If there are users that work with both projects, you could maybe add some solution that shares the login session across both CRM instances (e.g. single sign-on) for convenience reasons. I don't know if there are good solutions for that available.
If you however decide to use a single CRM for both projects, I only see those options:
Use Team Security to control which record can be seen/accessed by which teams->users (a.k.a. row level security). This is a built-in feature in commercial versions of Sugar. For SugarCRM CE and SuiteCRM there appear to be similar 3rd party plugins available for purchase.
Create different account/contacts/opportunity modules for the projects in ModuleBuilder. I strongly advice against this, especially if you use forecasts. There are tweaks, features and functionality that are programmed to only work with the default modules. Those will not work properly with such custom modules. So additional to the effort of creating those modules (and maybe keeping their customizations in sync, if they are supposed to be the same across both projects) you will also have to fix/work-around/code things that work in the default modules but not in the custom ones. If the projects are wildly different and of sufficient size to justify the extra effort, this could be worth it. Otherwise: don't
I need a bit of clarity regarding whats possible with grails plugins before committing my self to a corner a month or two down the line,
We have two applications built in Grails what share the same model, however we are looking at creating a single application which will control the ACL and add the two Grails applications as plugins.
Now the two applications are very extensive and they have their own controllers, views and routing.
Is it still viable to integrate the two applications as grails plugins or is there another better way of doing it. In the past I have found that following a quick simple guide / tutorial on how to create a grails plugin for instance, might not really explain the other issues I might encounter as I take the two big applications which use plugins of their own and try to convert them to plugins...
Any heads up information would be appreciated.
Everyone's needs are different. I'll simply explain what we've done on a current project and then you can use that to help make your decision.
We have a "common" grails plugin. This plugin contains all of our domains, controllers, layouts, views, css, images, and js that are shared throughout our grails applications. The common plugin has the spring-security-core plugin installed since the security domains are, well, common to all the other applications. However, each application that uses are common plugin still specifies its own security. It uses the domains from common as well as the spring-security-core plugin installed in common, but each application can control its own access points and lock down the URLs that need locked down.
We have an admin application
We have a customer facing application which has both secured and un-secure content.
And we have a couple other internal only applications that use our common plugin.
We've been at this for 6 months and haven't noticed any drawbacks to this approach.
Basically my project is product based.
Once we developed a project and catch the multiple client and deploy the application based on their needs.
But We decided to put the new features and project dependent modules are as component.
Now my application got many number of customer.
Every customer needs a different features based on the component.
But we have centralized component for all client . we move the components additional feature to client specific folder and deploy.
My problem is , I am unable maintain the components features for multiple client.
My component feature code is increased and I am unable to track the client features.
Is there any solution for maintaining the multiple component features for multiple client ?
I've worked for a couple of companies in a similar space - product software but very heavily customised.
Essentially there is a decision the company needs to make - are you a product company (that is you ship broadly the same to every client) or are you a bespoke company. At the moment it sounds like they're between two stools and wanting the economies of being a product company with the ability to meet specific client demands the way a bespoke software company can.
Assuming the company wants to be a product software company, unless there are specific technical reasons why you can't, you need to move to a single code base with the modifications for each customer being handled through customisable options (i.e. flags saying how this particular situation is being handled, whether this feature is available and so on).
These can be set at run time (so they can be changed as the client wants - think options in Word or Excel), or build time (so code is included / excluded when you do the build), but the key things is that every client has to be pulled from the same code base.
But this needs to be agreed with the business as it limits what they can sell - every change they sell has to fit into an overall vision which can be accommodated by the single product.
The alternative is that you're essentially producing bespoke software for each client (that is coded specifically for what they want) but using many common libraries. That's fine and allows you to produce something which is exactly what they want but in the end it is going to be more work and the business needs to understand and cost for that.
We actually do a bit of both - there is a server product which is identical for all clients, and then web and mobile clients which are specific to them (in the case of mobile you can't have lots of dead code on the device - the web stuff is historic and will be moving to a standard product for all clients).
Good luck though, it's a difficult problem with no easy solution.
You are essentially talking about software product lines (SPLs): variations from a common base. Since you already package your features as components, you need a specialized tool to manage such variations.
You can then build a complete custom application based on a configuration that is unique to any given customer. Easier said than done, of course.
A model-driven software development(MDSD) approach can help a lot on this task. One such system that can support this development setup is ABSE, an emerging MDSD approach that among other things, can implement a software product line (info at http://www.abse.info - Disclaimer: I am the ABSE project lead). There is no product yet though. An alpha preview is coming.
Again, I know some companies that, using an MDSD coupled with code generation, have achieved what I understand you want: products that are half pre-packaged, half custom.
Programmers that actually promote their products to production need an installer. (pre-emptive "programming related" justificaton.)
For deploying a new suite of internal corporate apps and services, I'm trying to decide between using WIX and the InstallShield Express edition that comes with Visual Studio 2010.
I've looked, but haven't found a feature matrix that highlights the features that are not in the express edition. I expect WIX to be generally quite capable, but more difficult to use, and have heard of situations that WIX doesn't support well.
Has anyone found a feature matrix, or have other recommendations on the long-term best way to manage internal deployments?
I find that wix is a great choice (in spite of the very very steep learning curve) if you need to manage installers in a complex environment because
setup definitions are stored in an XML format
it gives you full control to the underlying windows installer technology; the XML schema typically closely follows the windows installer database schema (which is also the main reason why the learning curve is so steep)
It is easy to integrate into your automated build
Parts of the setup can be generated automatically
It allows you to define small reusable modules and manage complex dependencies between them.
no cost or licensing issues (before wix we all had to use a single "Installshield PC")
Why the XML format is an advantage: this allows you to fully leverage code versioning systems like subversion or mercurial. Reviewing changes, examining history or even merging changes across branches is a breeze. Compare that to installshield projects which are opaque binary blobs.
What I mean by managing complex dependencies: in our case we have a big pool of reusable component libraries with a complex set of dependencies between them, and many applications that were build on top of that. Before wix, this was a nightmare when a new dependency was introduced somewhere: ALL setups had to be updated.
Now with wix, we have a ComponentGroup for each library, organized into a couple wixlibs. Each component group references other component groups that it depends on with a ComponentGroupRef. Application setup developers only need to reference the component groups of direct dependencies, and wix will do the rest by following the references. As a result, introducing a new dependency only requires making a single local change. Our automated builds and wix do the rest to regenerate all the setups.
InstallShield Express is for basic deployments (it's nothing but glorified WinZip). You can also check my favorite AdvancedInstaller. They have also free express edition but I think both of them will be no use to you, because if you need to do anything with IIS, MS SQL, Active directory, GAC etc, you will need "enterprise level" editions. WiX is free but learning curve is so steep, that it's not worth learning. I regret ever learning it.
If you need this just for internal deployments and cannot spend $1,000 on installer, just create your own "installation" project from scratch. System.EnterpriseServices.Internal namespace contains some useful wrappers for IIS, GAC etc. System.Configuration.Install.ManagedInstallerClass can help you deploy windows services. In other words, you can make your own program from scratch that can handle all necessary steps for deployment of your primary product. Many companies don't use for their flagship products commercial installers, they make their own.
The feature matrix for Install shield can be found here:
http://www.flexerasoftware.com/products/installshield/features.htm
However, for the IIS section (I assume you need IIS based on the link to my earlier question) all it says is "Limited". It is up to you to guess what Limited means, but I am betting it will not support an enterprise level deployment.
My organization has begun slowly repurposing itself to a less product-oriented business model and more contract-oriented business model over the last year or two. During the past year, I was shifted into the new contracting business to help put out fires and fill orders. While the year as a whole was profitable (and therefore, by at least one measure, successful, we had a couple projects that really dinged our numbers for the year back around June.
I was talking with my manager before the Christmas holiday, and he mentioned that, while he doesn't like the term "post-mortem" (I have no idea what's wrong with the term, any business folks or managers out there know?), he did want to hold a meeting sometime mid-January where the entire contract group would review the year and try to figure out what went right, what went wrong, and what initiatives we can perform to try to improve profitability.
For various reasons (I'll go into more detail if it's requested), I believe that one thing our team, and indeed the organization as a whole, would benefit from is some form of organized code-sharing. The same things get done again and again by different people and they end up getting done (and broken) in different ways. I'd like to at least establish a repository where people can grab code that performs a certain task and include (or, realistically, copy/paste) that code in their own projects.
What should I propose as a workable common source repository for a team of at least 10-12 full-time devs, plus anywhere from 5-50 (very) part time developers who are temporarily loaned to the contract group for specialized work?
The answer required some cultural information for any chance at a reasonable answer, so I'll provide it here, along with some of my thoughts on the topic:
Developers will not be forced to use this repository. The barrier to
entry must be as low as possible to
encourage participation, or it will
be ignored. Sadly, this means
that anything which requires an
additional software client to be
installed and run will likely fail.
ClickOnce deployment's about as
close as we can get, and that's awfully iffy.
We are a risk-averse, Microsoft shop. I may be able to sell open-source solutions, but they'll be looked upon with suspicion. All devs have VSS, the corporate director has declared that VSTS is not viable going forward. If it isn't too difficult a setup and the license is liberal, I could still try to ninja a VSTS server into the lab.
Some of my fellow devs care about writing quality, reliable software, some don't. I'd like to protect any shared code written by those who care from those who don't. Common configuration management practices (like checking out code while it's being worked on) are completely ignored by at least a fifth of my colleagues on the contract team.
We're better at writing processes than following them. I will pretty much have to have some form of written process to be able to sell this to my manager. I believe it will have to be lightweight, flexible, and enforced by the tools to be remotely relevant because my manager is the only person who will ever read it.
Don't assume best practices. I would very much like to include things like mandatory code reviews to enforce use of static analysis tools (FxCop, StyleCop) on common code. This raises the bar, however, because no such practices are currently performed in a consistent manner.
I will be happy to provide any additional requested information. :)
EDIT: (Responsing to questions)
Perhaps contracting isn't the correct term. We absolutely own our own code assets. A significant part of the business model on paper (though not, yet, in practice) is that we own the code/projects we write and we can re-sell them to other customers. Our projects typically take the form of adding some special functionality to one of the company's many existing software products.
From the sounds of it you have a opportunity during the "post-mortem"to present some solutions. I would create a presentation outlining your ideas and present them at this meeting. Before that I would recommend that you set up some solutions and demonstrate it during your presentation. Some things to do -
Evangelize component based programming (A good read is Programming .NET Components - Jubal Lowy). Advocate the DRY (Don't Repeat Yourself) principle of coding.
Set up a central common location in you repository for all your re-usable code libraries. This should have the reference implementation of your re-usable code library.
Make it easy for people to use your code libraries by providing project templates for common scenarios with the code libraries already baked in. This way your colleagues will have a consistent template to work from. You can leverage the VS.NET project template capabilities to this - check out the following links VSX Project System (VS.Net 2008), Code Project article on creating Project Templates
Use a build automation tool like MSBuild (which is bundled in VS2005 and up) to copy over just the components needed for a particular project. Make this part of your build setup in the IDE (VS.NET 2005 and up have nifty ways to set up pre-compile and post-compile tasks using MSBuild)
I know there is resistance for open source solutions but I would still recommend setting up and using a continuous automation system like CruiseControl.NET so that you can leverage it to compile and test your projects on a regular basis from a central repository where the re-usable code library is maintained. This way any changes to the code library can be quickly checked to make sure it does not break anything, It also helps bring out version issues with the various projects.
If you can set this up on a machine and show it during your post-mortem as part of the steps that can be taken to improve, you should get better buy since you are showing something already working that can be scaled up easily.
Hope this helps and best of luck with your evangelism :-)
I came across this set of frameworks recently called the Chuck Norris Frameworks - They are available on NuGet at http://nuget.org/packages/chucknorris . You should definitely check them out, as they have some nice templates for your ASP.NET projects. Also definitely checkout Nuget.
organize by topic, require unit tests (feature-level) for check-in/acceptance into library; add a wiki to explain what/why and for searching
One question: You say this is a consulting group. What code assets do you have? I would think most of your teams' coding efforts would be owned by your clients as part of your work-for-hire contract. If you are going to do this you need to make absolutely certain that your contracts grant you rights to your employees' work.
Maven has solved code reuse in the Java community - you should go check it out.
I have a .NET developer that's devised something similar for our internal use for .NET assemblies. Because there's no comparable .NET Internet community, this tool will just access an internal repository in our corporate network. Otherwise will work rather much the way Maven does.
Maven could really be used to manage .NET assemblies directly (we use it with our Flex .swf and .swc code modules) is just .NET folk would have to get over using a Java tool and would probably have to write a Maven plugin to drive msbuild.
First of all for code organization check out Microsoft Framework Design Guidelines at http://msdn.microsoft.com/en-us/library/ms229042.aspx and then create a central Location source control for the new framework that your going to create. Set up some default namespaces, assemblies for cleaner seperation and make sure everyone gets a daily build.
Just an additional point, since we have "shared code" in my shop as well.
We found out this is very much a packaging issue:
Whatever code your are producing or tool you are using, what you should have is a common build tool able to package your sources into a "delivery component", with everything used to actually execute the code, but also the documentation (compressed), and the source (compressed).
The main interest into having a such a "delivery package unit" is to have as less files to deploy as possible, in order to ease the download of those units.
The build process can very well be managed by Maven or any other (ant/nant) tool you want.
When some audit team want to examine all our projects, we just deploy on their post the same packages we deploy on a production machine, except they will un-compressed the source files and do their work.
Since our source files also includes whatever files are needed to compile them (like for instance eclipse files), they even can re-compile those projects in their development environment).
That way:
Developers will not be forced to use this repository. The barrier to entry must be as low as possible to encourage participation, or it will be ignored: it is just a script to execute to get the "delivery module" with everything in it they need (a maven repository can be used for that too)
We are a risk-averse, Microsoft shop: you can use any repository you want
Some of my fellow devs care about writing quality, reliable software, some don't: this has nothing to do with the quality of code written in these packages modules
We're better at writing processes than following them: the only process involved in this is the packaging process, and it can be fairly automated
Don't assume best practices: you are not forced to apply any kind of static code analysis before packaging executable and source files.