Re: Starting to modularize legacy
Josh Holtzman wrote:
As a first attempt at decoupling all of the services that are jammed
into legacy, I just pulled the entity package out of /legacy-service
into its own jar. Because it has dependencies on other legacy stuff,
the new jar must include the exceptions, time, and user packages from
According to my analysis, the Entity dependencies are: Site, User,
Time, and Exception. The dependencies on Time are understandable, to
some degree and we could live with that. The exceptions associated with
entity should be defined and bundled with entity, rather than shared.
This greatly reduces cross-service dependencies, as far as exceptions go.
Dependencies on User could be eliminated by returning a User Id string.
This doesn't really reduce the dependency. It just decouples the
services by making the reference more abstact (String vs. User). Still,
it would make it much more modular. Note also the circular definition:
User entends Entity, Entity relies on User. This feels wrong to me.
I also had to change the EntityProducer interface's
syncWithSiteChange(Site site, ChangeType change) to
syncWithSiteChange(String siteId, ChangeType change) to keep the Site
dependency out of the framework.
This is the Site dependency noted above. I have mentioned this to Glenn
in the past and there was some discussion about alternative approaches
at that time. Personally, I think that a reference to Sites at the
Entity level is completely wrong. It totally violates the layering of
services. I think we should consider moving it into the Site Service
(if possible) or consider developing a synchronization service of some
kind. It sholdn't be in Entity at all. That said, your proposed change
reduces coupling. I could live with that.
Many of maven's project.xml files also needed to be edited to add the
new dependency, which I called sakai-legacy-entity.
That would follow.
Perhaps this can be the start of a "framework" layer below legacy?
Entity should be in common, if it is going to be the base construct for
system resources (called Qualifiers in OKI-speak). Common should be the
basis for the new Sakai framework. Kernel is below it, application and
education services above it. Legacy services need to be evaluated on a
case basis to see where they fit.
We can't really move entity into common at this time, though. Not
without making some of the design changes I mentioned above. Nothing in
common should depend on legacy services. Putting it into it's own JAR
is just a holding action until we can separate it's concerns and reduced
service coupling. What is really gained by putting it into it's own
JAR? Can the legacy services be split up by doing that?
If we are considering a new entity that could be in common, we should
give some thought to the mix-in vs. interface extension design
patterns. There are advantages to the current approach, but mix-ins
have a lot to say for themselves, too. To my mind, Entity should
provide very basic capablities that we want all resources to have. It's
pretty close to where it needs to be, I think.
The good news is that this took only about two hours to accomplish,
and Sakai seems to be running happily. I couldn't make a
comprehensive patch for this, since svn wouldn't include any of the
"added" files (svn help anyone?). Let me know if you want to look at
the changes, and I'll zip it up and send it out.
I'm hoping that other minor API tweaks will allow the rest of legacy
to be modularized.
Modularized how? Do you think you can split the legacy services each
into their own JARs? Certainly pulling the legacy tools out is a very
good thing. Does it make sense to discuss what services should be
clustered? Are there services that could be moved to common?
- Mark Norton
This automatic notification message was sent by Sakai Collab
) from the WG: Framework site.
You can modify how you receive notifications at My Workspace > Preferences.