Notes on Installing Ceiling Fans

It seemed daunting to install a ceiling fan myself but it didn’t turn out to be too challenging. It was also a rewarding exercise since it could cost upward of $100 per fan based on one quote and a label in the store. However, there were some false starts so I am saving the lessons here. These are notes to myself and may not be deemed as an advice for any purpose, whatsoever.

1. I started with a web search on “how to install a ceiling fan” and talked to some folks who had done this before.
2. A 44″ fan should probably serve only big closets, assuming someone bothered to install a fan there. It works just OK in a 12′x10′ room. A 50″ fan feels the right size in such a room.
3. Flush mount (or close mount – without a downrod) installation is the way to go for 8′ high ceiling. Some fans don’t offer this option, so remember that when buying one.
4. Many fans use candelabra base for lighting fixture. Though there are fluorescent lamps available for this base, my regular spare ones won’t fit.
5. I did buy braces and boxes for ceiling mount though I ended up not needing them.
6. When starting work, always turn the power off first and verify. I got this right but I couldn’t go wrong with this reminder.
7. An appropriate ladder is handy.
8. Remember to remove the downrod support from mounting brackets when doing a flush installation.
9. I had a good/strong outlet box on a brace already in place in the ceiling and I was replacing a light fixture which was installed with only one screw. So I had to find another matching screw for installing the bracket.
10. Remember to use washers on screws when attaching the mounting bracket to the outlet box.
11. The brackets with a J hook to hang the fan assembly make muscular arms/shoulders an optional trait for wiring skills.
12. The canopy ring or cover is one of the first things to be used in assembly. The first time I missed it and had to redo the assembly. I was lucky on the other fan where I had the canopy cover oriented with the right side up when I checked.
13. That black unused wire in the outlet box was for the other switch which appeared to be a decorative item before. Use it for separate control of fan and light.
14. I bought three different models, and the Hunter Five Minute fan turned out to be best looking/performing and easiest to install.
15. With a downrod installation ensure that the ball clicks into the wedge on the bracket intended to keep it in place.
16. The downrod installation I did had a slight oscillation on the rod (like a pendulum), though not to a disconcerting degree.

FREE EMC Documentum Developer Edition

For the first time, EMC has released a Documentum Developer Edition Package which is available as a free download. It gives an opportunity for new devlopers to build their skills on Documentum before they have formal access to Documentum through a job or training. Of course, it also gives a try-before-you-buy opportunity to potential customers. Read more here.

Book Review: SugarCRM Developer’s Manual

This is a review of the book – SuagrCRM Developer’s Manual by Dr. Mark Alexander Bain. Click on the cover image to see the publisher’s page for the book. The book is published by PACKT Publishing – an active supporter of open-source projects.

Disclaimers / Disclosures

1. This review represents my independent opinion.
2. I have not been paid for this review.
3. The publisher has provided me with a free copy of the book for writing this review.

Approach

This review does not attempt to provide information about SugarCRM outside the context of the book. The review focuses on what the book offers, what it does well, and where it could have done better. Content outline and information about the author is present on the publisher’s page for the book.

Review

Before I start the review, I must admit that I have not worked much with SugarCRM but I do have significant development experience. As such, I might call myself a “beginner-level developer” as far as SugarCRM customization is concerned. Therefore, my review should probably be qualified for beginner-level SugarCRM developer rather than an experienced one. I make this qualification because I have seen some other reviews which are harsh on this book with regard to certain development aspects that seem to be inadequately covered.

As a first-time SugarCRM developer, my feeling after reading the book was that customizing SugarCRM is easy. It is in large part due to the excellent work by the author . The author’s style and the organization of content made it a breeze to go through most of the book. Before I could put the book away thinking that the book addressed only simple scenarios I ran into the last four chapters of the book. These chapters alone could make the book a worthy buy.

This book is a blend of gentle introduction, reference material, and real-world advice. I am always looking for real-world experience and recommendations in a book since the introduction and reference material are often available from other sources. Some of the advice in the book goes beyond SugarCRM and applies to PHP-mySQL applications in general.

Good introductions can also be valuable and this book is certainly a good choice if you are looking for one. The book also devotes 60 pages to database dictionary, which I mostly skipped. For such information, I like to directly query a database instance but I can see how these pages can provide a useful reference while reading the book.

The book has plenty of code samples and screenshots, which make it easy to follow. It is also helpful that the book uses a single business scenario and builds upon it throughout the book. It helps to see natural progression from simple to complex in some cases and interrelationships in others.

The book uses version 4.5 and the latest one is 5.2. The next version after 4.5.1 was 5.0, which became available in early 2008. A quick look at the release notes for 5.0 did not seem to indicate huge differences between 4.5 and 5.0. However, another reviewer has indicated that there are several important differences between 4.5 and 5.x. So you may need to do your homework to figure out whether this book can serve your needs.

The book starts with some quick and easy customizations of look and feel as a warm-up. Then it shows how to add custom tabs, dashlets, and custom fields. Next it describes the architecture of the application followed by the details of the database structure. I love the material that comes after this point. Some good advice about development, testing, and upgrades. The knowledge shared here is sometimes applicable to other PHP-mySQL applications as well. This is followed by the advanced topics of writing custom modules and workflows. The book concludes with tips on tuning SugarCRM and writing reports. I feel that it is the last 4 chapters that will add the most value in any real-world customization of SugarCRM.

Conclusion

This is an excellent handbook for beginner-level developers customizing SugarCRM version 4.5. For other situations, it may or may not be what you need so you need to do some analysis before selecting this book. Also note that this is not a book about making the best use of SugarCRM. That is not a shortcoming of the book because the book clearly identifies its audience and purpose – customization for developers. If you are looking for a book about using SugarCRM then maybe you should look at Implementing SugarCRM.

UCF Error: ExceptionInInitializerError

One of our Documentum users ran into this exception when doing a simple import via Webtop:

invokeMethod() failed while calling: onOk
An error has occurred when invoking the UCF runtime. Details:
java.lang.ExceptionInInitializerError

This user had performed imports successfully in the past. Everything else seemed to be in order. After asking around, I got this suggestion which actually fixed the problem. Apparently, UCF keeps stuff in a local folder which sometimes gets corrupted. Deleting (or renaming) this folder causes UCF to reinitialize its “cache”. Look for this folder in a location like C:\Documents and Settings\USERID\Documentum\ucf

Real-Life Service-Oriented Architecture (SOA) with D6

I contributed an article for EMC Proven Professional Knowledge Sharing 2008 entitled Real-Life Service-Oriented Architecture (SOA) with D6. It has now been published on EMC Education Services site. On the same topic, I also wrote an article on CMSWire.

For ease of access, the article is being made available here as well (with permission from EMC) – download article. The abstract of the article follows.

Abstract

Service-Oriented Architecture (SOA) facilitates composition of loosely-coupled services into new services and applications. SOA must deliver business and technical agility to be successful. In other words, SOA serves business goals other than the standard “potential cost reduction via technical changes.”

This article translates a real-life business goal into an SOA solution that includes a key service provided by D6 (EMC Documentum version 6). While the article is primarily technical, it keeps business drivers and context at the forefront.

Even as SOA is becoming mainstream, Enterprise Content Management (ECM) has become a key piece of the enterprise infrastructure puzzle. Explosive content growth has led Gartner to forecast a 12% annual growth in ECM software revenues for the next three years. EMC Documentum has been a leading player in the ECM space so it should come as no surprise that SOA has been adopted as one of the core principles of D6.

D6 provides Documentum Foundation Services (DFS) for plugging Documentum into an SOA solution. Documentation and articles about D6 and SOA typically focus on DFS features. While they are essential for using Documentum in an SOA solution, they need another complementary capability for completing the SOA picture – orchestration of services for composing new services or applications. This article explores implementation of a real-life business scenario via an SOA solution including Documentum as a key component.
Consider a business goal to reduce Days Sales Outstanding (DSO) defined as the average collection period of account receivables over a time period (typically quarterly or yearly). A large DSO value means that it takes longer for the business to collect payments. A process analysis reveals that invoice presentment and payment are the primary improvement opportunities. This article describes an SOA-based implementation of an Invoice Presentment and Payment Application. Documentum is used to manage payment-related documents such as invoices and payment receipts.

The article illustrates the following key aspects of such a solution:

1. Using DFS for creating content-oriented services
2. Orchestrating SOA services for composing applications or other services
3. Addressing real-life concerns

Book Review: Alfresco Developer Guide

This is a review of the book – Alfresco Developer Guide by Jeff Potts. Click on the cover image to see the publisher page for the book. The book is published by PACKT Publishing – an active supporter of open-source projects.

Disclaimers / Disclosures

1. This review represents my independent opinion.
2. I have not been paid for this review.
3. The publisher has provided me with a free copy of the book for writing this review.

Approach

This review does not attempt to provide information about the Alfresco platform outside the context of the book. The review focuses on what the book offers, what it does well, and where it could have done better. Content outline and information about the author is present on the publisher’s page for the book.

Review

While Alfresco by Munwar Shariff got you started with Alfresco, Alfresco Developer Guide by Jeff Potts gets you going. The first book provides good overview of the breadth of features and Alfresco Developer Guide dives deep into customization for Alfresco-based solutions. Content management is a general requirement but its applications vary significantly. Without accommodating the specific needs of the business, a content management system (CMS) would usually be little more than a glorified file system.

As I started reading the book, it quickly became evident that the author had significant hands-on experience with customizing Alfresco. The book has detailed examples with code and screenshots. The step-by-step directions with practical advice and recommendations make it easy to follow. The book uses Alfresco 2.2 Enterprise and 3.0 Labs versions. In one sentence, I would characterize this book as an illustrated handbook for customizing Alfresco.

The book starts with a description of the Alfresco Platform. This includes overview of content management, the architecture of Alfresco-based solutions, the example used throughout the book, and various kinds of customizations that can be done with Alfresco. It is followed by directions for setting up an Alfresco development environment using Eclipse. Detailed discussion of customization starts with creating custom models – which includes types, associations, and aspects. The UI changes and programmatic access to go with custom content model are also discussed. Automated processing of content with actions, behaviors, transformers, and extractors is discussed next. Web client customization discusses how to adapt the UI for specific needs. The book also discusses implementation of RESTful API using Web Scripts. Workflows are an important feature of content management systems. The book discusses implementation of advanced workflows using jBPM. jBPM enables you to implement complex workflows within Alfresco platform. Web Content management is a popular and common application of content management systems. The book discusses web content management on Alfresco using Alfresco WCM. The book concludes with a discussion on security, including incorporating Alfresco in a Single-Sign-On solution. The appendix includes API reference and examples.

Given my experience with EMC Documentum, I couldn’t help but compare the details with how I do things with Documentum. This book provided the depth to make such a comparison possible. One would normally use this book as a reference to jump to the task at hand and follow a step-by-step example. If you need to understand the breadth, you can skip over example details and read it in a flow. However, in my opinion, the best value provided by this book is in terms of best practices and practical advice which is hard to find in product documentation.

The author does not skimp on sharing practical advice. A fundamental advice is around separation of solution files from Alfresco files. The author also discusses various options for packaging and deployment of customizations. The troubleshooting tools and practices discussed would benefit any Alfresco developer. Modeling best practices are also very important since the custom content model is usually the foundation of a custom solution on Alfresco. When creating a solution for a large organization, advice about handling large directories for user/group synchronization would be handy. Other tips such as dealing with cross-domain scripting limitation and implementing Single-Sign-On also add value.

I think that it is a great book for people who are already working with Alfresco or another content management system. Readers new to the content management space may need a gentler introduction to the concepts and to Alfresco before they can derive maximum value out of this book.

Conclusion

Even if you had the expertise to write this book, you might want to keep a copy handy if you frequently implement solutions using Alfresco. If you are new to Alfresco this book is even more valuable. If you are new to content management in general then you may want to ramp up with some other resources before making the best use of this book.

Handy DQL: What is being audited?

Whether we need to configure auditing for a new solution or figure out why some event was not audited, we may have to answer the question, “What is currently being audited in my repository?” Here are some handy queries to help you do just that.

List all configured audit events

This query is not very helpful other than getting the total count and the object ID’s. The queries that follow later join with various types to provide user-friendly information.

select r.registered_id, r.event,r.user_name
from dmi_registry r
where r.is_audittrail = 1

Across-the-board  audit configuration

select 'ALL',r.event,r.user_name
from dmi_registry r
where r.is_audittrail = 1
and r.registered_id = '0000000000000000'

Audit configuration for types

select t.name,r.event,r.user_name
from dmi_registry r, dm_type t
where r.is_audittrail = 1
and t.r_object_id = r.registered_id


Audit configuration for Sysobjects

select t.object_name,r.event,r.user_name
from dmi_registry r, dm_sysobject t
where r.is_audittrail = 1
and t.r_object_id = r.registered_id


Audit configuration for users

select t.user_name,r.event,r.user_name
from dmi_registry r, dm_user t
where r.is_audittrail = 1
and t.r_object_id = r.registered_id


Java Evaluation of Docbasic Expressions

Huh? Exactly.

After an upgrade to SP5 from 5.3 SP3 we started getting regular crashes of Weblogic, which was hosting the WDK apps. After looking at various crashes we were still struggling to find something common among the crash instances. Finally, we discovered that every crash that left a dump file showed a stack trace of expression evaluation for conditional value assistance. It didn’t indicate the expression it was evaluating but it did show that it was going outside the JVM via JNI and crashing there.

Fast forwarding to the EMC response. They had encountered something similar in another case and the recommendation was to migrate docbasic expressions to Java implementation! Huh?

Well, Appendix B of DQL Reference describes this process in a reasonable detail. Apparently, for evaluating the conditions in value assistance (among other things) DFC uses a DLL which is a Docbasic runtime. However, it is possible to provide a Java implementation for expressions so that the need for JNI calls can be obviated. The methods available for this purpose are called dmc_MigrateDbExprsToJava and dmc_MigrateDbExprsToJavaForType.

If you follow this documentation in conjunction with the object reference it will all begin to make sense. The only additional worthwhile thing to know, and probably the biggest value addition offered by this post, is the following.

Once you have created the Java implementations for Docbasic expressions, you can disable and enable the use of these Java implementations. However, when we tried to disable the use of these expressions using dmc_SetJavaExprEnabled, the command failed. When we got to the logs, we found various errors but one caught our eye. It complained about missing a parameter named “enabled”. However, the reference names the parameter as “enable” (which turns out to be incorrect). Once we corrected the parameter name to be “enabled” in the command line, it started to work as expected.

In order to troubleshoot this issue, we wrote a small DFC client that iterated through docbase objects and exercised all the conditions present in value assistance. We embedded this client in a JSP so that we could reproduce it in the environment that was encountering the problem. Using this tool, we were able to reproduce the problem consistently. The tests following the change have been encouraging since we haven’t seen any more crashes.

Decoding xperms

Object permissions are stored as integers in Documentum ACL objects. For each accessor, there is one value (1-7) which represents one of None, Browse, Read, Relate, Version, Write, and Delete. These permissions are hierarchical, so 4 would imply 4 and everything below it.

ACL’s also include extended permissions. An accessor can be assigned a subset of Change Location, Change Ownership, Change Permission, Execute Procedure, Change State, and Extended Delete. All of these values are independent and they can be assigned in any combination to one accessor in an ACL. However, there is only one field to store the extended permissions for one accessor. The obvious way to store such information is using bit fields and, indeed, that is how it is stored in the repository. There is only one catch though – the details are hard to find until you hit the DFC Javadocs for IDfACL. There you can find the specs under the method getAccessorXPermit().

You would think that that’s the whole story but it isn’t. It’s very easy to get it wrong like this post did. The bits at position 0 and 1 are interpreted in a reverse manner compared to the rest of the bits – 0 means has permission and 1 means doesn’t. That is why “no extended permissions” is encoded as 3!

That’s about it. The only additional piece is that D6 has added a new extended permission – Change Folder Links. The Javadoc for bit-encoding hasn’t been updated to reflect this change. However, it will be pretty easy to figure out by dumping an ACL object containing that extended permission.

[UPDATE] Here is the obvious way to implement it using the bit-wise AND operator (&).
// assuming that R_ACCESSOR_XPERMIT contains the integer value to be decoded
boolean execProc = (R_ACCESSOR_XPERMIT & 1) == 0;
boolean chgLoc = (R_ACCESSOR_XPERMIT & 2) == 0;
boolean chgState = (R_ACCESSOR_XPERMIT & 65536) != 0;
boolean chgPerm = (R_ACCESSOR_XPERMIT & 131072) != 0;
boolean chgOwner = (R_ACCESSOR_XPERMIT & 262144) != 0;
boolean extDelete = (R_ACCESSOR_XPERMIT & 524288) != 0;


And just for fun, here is another way to implement this decoding without using bit-wise operations. The % is the mod operator which takes the remainder after division.
// assuming that R_ACCESSOR_XPERMIT contains the integer value to be decoded
boolean execProc = (R_ACCESSOR_XPERMIT%2) == 0;
boolean chgLoc = (R_ACCESSOR_XPERMIT%4) - (R_ACCESSOR_XPERMIT%2) == 0;
boolean chgState = (R_ACCESSOR_XPERMIT%131072) - (R_ACCESSOR_XPERMIT%65536) != 0;
boolean chgPerm = (R_ACCESSOR_XPERMIT%262144) - (R_ACCESSOR_XPERMIT%131072) != 0;
boolean chgOwner = (R_ACCESSOR_XPERMIT%524288) - (R_ACCESSOR_XPERMIT%262144) != 0;
boolean extDelete = (R_ACCESSOR_XPERMIT%1048576) - (R_ACCESSOR_XPERMIT%524288) != 0;


Who Owns this Repository?

You need to figure out the repository owner for a repository. What do you do?

Guess, it’s dmadmin. Well, dmadmin is the conventional installation owner. Indeed, it is possible that there is no user named dmadmin in a repository.

So, maybe use the installation owner – the user id on OS used for installing the Content Server. Well, installation owner is separate from repository owner and there is no requirement for the two to be the same. Actually, they should be kept separate – in many organizations installation responsibilities are separated from day-to-day administration responsibilities.

Hmmm, is it same as the repository name? Maybe. When you configure a new repository, you have a choice to set up the database beforehand or to let the configuration script set it up for you. If you let the script do this work, it defaults the DB account to be the same as the repository name. In this case, this guess would be valid. However, it is not required to be so. If the database is already set up, you can provide this information to the configuration script and it uses the provided DB user to create the corresponding user in the repository. This user becomes the repository owner.

Then, is there an attribute on dm_docbase_config which identifies the repository owner? We are getting close. There isn’t an attribute called docbase_owner or repository_owner. However, the owner of the docbase config object (identified by owner_name) is the repository owner. If you are looking for the exact DB login name for the repository owner then look at the user_db_name attribute on the user object for the repository name. For the repository owner, it is same as the user_name by default.

Also, the operator_name on a dm_server_config object defaults to the repository owner name. Remember that this is just a default. Further, there can be multiple content servers serving one repository.