[IDEA] Connector level save and deploy

[thorst]

We have a lot of channels and a lot of developers. This can cause collisions where two developers are trying to modify the same channel at the same time. They don't realize there is a potential issue until after they have made a bunch of changes and they go to save and realize someone saved a newer copy than what they had loaded. They should then copy any changes they have out, try to determine who else was making changes, and see if there are conflicts with their pending changes, refresh their config, reinstate changes, and then save and deploy.

I'm requesting that we have the ability to "save a connector" specifically. What this would look like programmatically, since it's all in one xml blob in the database, is that:

1. Get the config from the db
2. overwrite the connector level code for that connector
3. save to the db

Then a "publish connector" feature could be added, utilizing similar functionality, where just the connector we are working on gets published because there may be changes to other connectors we don't want to publish.

This means the current publish feature basically gets relegated to only being used when it's a new channel, or there is high level change to the channel that's above the connector level.

Other thoughts:

1. It would be better to store all the config for a channel in relational tables, instead of a xml blob in the database. Only when we are exporting and importing should it be converted to xml. I assume this is a gigantic change though.
2. I'm putting in another request for connector/channel "locking". This would grab the user that is editing, and either warn or block a subsequent user from accessing until the previous user is done editing
3. Using more channel reader/writers to minimize destination editing conflicts helps so that most of the code lies in an independent channel, however, this feels against the grain as to what would be most efficient. There is more parsing the transaction, more saving states to a database, more overall processing that is only done in an effort to stymie people from stomping on each other