Daemon Service for Graphite

A daemon is a program running in the background, usually providing some sort of service.” enabling other work in the “foreground,” and is independent of control from a terminal. Typical daemons that provide e-mail, printing, telnet, FTP, and web access.

Daemons can either be started by a process, such as a system startup script, where there is no controlling terminal, or by a user at a terminal without “tying up” that terminal
Here we used this technic in Graphite to automate the servers of the Graphite. So we plan to start carbon and graphite server automatically using daemon.

The daemons referenced in /etc/init.d are configured to be run as Linux services. Services are programs that are started and stopped through the init scripts in the /etc/init.d directory. Many of these services are launched when the system is booted. The /sbin/service utility provides a consistent interface to executing the init scripts. The init scripts provide a consistent interface to managing a service by providing options that start, stop, restart, query status.

For Code Breakers


Here's a short collection of quotes from Clean Code, with my comments added after each quote.

"Later equals never."
In our youth we always said, "I'll clean up the code later", but of course we never did. "Later equals never" is known as LeBlanc's Law.


"The only way to make the deadline -- the only way to go fast -- is to keep the code as clean as possible at all times."
The only thing I'd change in that quote is to say, "the only way to constantly go fast". You can go fast in the short term by taking shortcuts, but not in the long term.


"Clean code always looks like it was written by someone who cares."
This was written by Michael Feathers. This quote reflects something I stress during training and mentoring sessions. Programmers need to think of themselves as craftsmen, and take pride in their work. Maybe customers can't see your work, but other developers certainly can, and you should take pride in writing crisp, clear code that other programmers can easily read and comprehend.


"Leave the campground cleaner than the way you found it."
This is similar to the previous quote. I didn't know it, but this is a Boy Scouts of America rule/slogan. In Alaska they have the exact same statement about using the Public Use Cabins here, leave it in better shape than the way you found it.


"The ratio of time spent reading (code) versus writing is well over 10 to 1 ... (therefore) making it easy to read makes it easier to write."
This was something I never really thought about before, but Uncle Bob Martin makes a very convincing case that when we're working on software projects with other developers, we're constantly trying to understand existing code when writing new code, to see how our new code should work and fit into the system.


"You know you are working on clean code when each routine you read turns out to be pretty much what you expected. You can call it beautiful code when the code also makes it look like the language was made for the problem."
That quote comes from Ward Cunningham (inventor of the Wiki, inventor of Fit, co-inventor of eXtreme Programming, and much more), who seems to be one of the greatest programmers of our time. I haven't met him yet, but whenever I read his writing, he blows me away. That statement alone sold me on this book.
Make your code read like a story


"The LOGO language used the keyword 'TO' in the same way that Ruby and Python use 'def'."
I never worked with LOGO, but the author begins describing how code should read like sentences in a book. Later he adds:


"Make the code read like a top-down set of TO paragraphs.
Eventually he takes these thoughts to this excellent conclusion:



"Master programmers think of systems as stories to be told rather than programs to be written."
For me, that's a very powerful phrase. I suspect you probably need to read his book to really understand what he's saying here, but if you read the section where he writes about the LOGO "TO" statements, he makes his point very well.


"In order to make sure our functions are doing 'one thing', we need to make sure that the statements within the function are all at the same level of abstraction."
This is another great line, and something I hadn't thought of consciously before. If code in a function is doing one thing at a high level of abstraction, another thing at a medium level, and another at a low level, it's going to be very hard to read, whether you consciously know why, or not. (This really is an excellent observation.)

Functions

"The first rule of functions is that they should be small."
As you've probably read elsewhere, a function should do one thing, and only one thing.


"Functions should do something, or answer something, but not both."
As he states, a function should change the state of an object, or return some information about that object, but not both. I've run into many functions over the years where a function was named "setSomething", and then when I looked at the source for that function, I found that it did several other things besides the "set" it claimed to do.


"Methods should have verb or phrase names."
Very true. I'm always naming methods "handleXYZ", "getXYZ", "calculateXYZ", and so on, trying to use verbs and action names.


"One way to know that a function is doing more than 'one thing' is if you can extract another function from it with a name that is not merely a restatement of its implementation."
This is another great observation that I've never thought about consciously. Many times you can look at a function and obviously know it's trying to accomplish more than one thing, but other times you look at a function and all you can tell is that it's wrong ... it doesn't seem right for some reason, but you can't put your finger on it.


Comments

"Every time you write a comment, you should grimace and feel the failure of your ability of expression."
Like many experienced programmers, the author has been burned by out of date comments, useless comments, and so on, and has come to the conclusion many others have: Most comments are not needed, and if you feel the need to write a comment, you should consider rewriting your code to make it more readable.


"It is better to extract the bodies of the try and catch blocks out info functions of their own."
This is a clever technique that can be used to make try/catch blocks as readable as they can be.
Clean Code, and the Principles of OOD


RRDTOOL for Graphing

RRDtool is the OpenSource industry standard, high performance data logging and graphing system for time series data. RRDtool can be easily integrated in shell scripts, perl, python, ruby, lua or tcl applications.



It has the similar features as Graphite graphing. This is very use full in for industrial level approaches .
Also,

  • RRDtool stores data; that makes it a back-end tool. The RRDtool command set allows the creation of graphs; that makes it a front-end tool as well. Other databases just store data and can not create graphs.
  • In case of linear databases, new data gets appended at the bottom of the database table. Thus its size keeps on increasing, whereas the size of an RRDtool database is determined at creation time. Imagine an RRDtool database as the perimeter of a circle. Data is added along the perimeter. When new data reaches the starting point, it overwrites existing data. This way, the size of an RRDtool database always remains constant. The name "Round Robin" stems from this behaviour.
  • Other databases store the values as supplied. RRDtool can be configured to calculate the rate of change from the previous to the current value and store this information instead.
  • Other databases get updated when values are supplied. The RRDtool database is structured in such a way that it needs data at predefined time intervals. If it does not get a new value during the interval, it stores an UNKNOWN value for that interval. So, when using the RRDtool database, it is imperative to use scripts that run at regular intervals to ensure a constant data flow to update the RRDtool database.


RRDtool assumes time-variable data in intervals of a certain length. This interval, usually named step, is specified upon creation of an RRD file and cannot be changed afterwards. Because data may not always be available at just the right time, RRDtool will automatically interpolate any submitted data to fit its internal time-steps.

The value for a specific step, that has been interpolated, is named a primary data point (PDP). Multiple PDPs may be consolidated according to a consolidation function (CF) to form a consolidated data point (CDP). Typical consolidation functions are average, minimum, maximum.

After the data have been consolidated, the resulting CDP is stored in a round-robin archive (RRA). A round-robin archive stores a fixed number of CDPs and specifies how many PDPs should be consolidated into one CDP and which CF to use.

Reference :
http://en.wikipedia.org/wiki/RRDtool
http://oss.oetiker.ch/rrdtool/index.en.html

Graphite Custom page Creation


We have some procedures to Create the custom page for Graphite. The brief steps are,
   Define the URL path
   Create the Sample page Directory
   Create the Sample page HTML view
   Link the HTML with specific folder
   Call the Html from specific folder using Python


Step 1:
We have to set the URL path in urls.py file which is located in /opt/graphite/webapp/graphite/urls.py . In this file we have some set of line which contain the url paths . So inside of this line we have to add our own web path with the same pattern.
Example: If we have a Directory called Test (With my own functions) then we have to add a line in this file url.py with the same pattern as below,
('^Test/', include('graphite.Test.urls')),
^Test/                                  : This is the URL extension (What we type after localhost)
graphite.Test.urls : Calling the python URL file which is in graphite/test/
Note : URL extensions are Case sensitive .To avoid the complex make all links as lower case
Step 2:
Now we have to create the sample Directory. So to avoid the complex of the implementation we can copy the browser directory which is located in /opt/graphite/webapp/graphite/ and rename the browser directory as Test. Paste it in same location (/opt/graphite/webapp/graphite/) So the Test Directory will contain the same files, which are in default page. Now we can edit the Test folder which contain url.py and views.py files. Each file we have some small changes.
The /opt/graphite/webapp/graphite/test directory contain url.py and views.py. Now change the graphite.browser.views as graphite.test.views to access our own page.
Similar Change the browser.html page as test.html in views.py file.
/opt/graphite/webapp/graphite/templates/test.html
Step 3:
Now we have to Create the HTML page for test with that what we mention above .So for that we have to create html file in /opt/graphite/webapp/graphite/templates/ as test.html.
Step 4:
Design the Page with your own Specification.
So finally we have to work with only three files for custom page creation
urls.py
views.py
test.html
Done.

Make file Sample Code for Porting libRFID from Linux to Anroid


MY_PATH := $(call my-dir)/librfid-0.2.0

LOCAL_PATH := $(MY_PATH)/src/ \
  $(MY_PATH)/src/ccid

include $(CLEAR_VARS)

# path for Header files
LOCAL_C_INCLUDES := $(MY_PATH)/include

#C files added from the src/ path
LOCAL_SRC_FILES := usleep.c rfid.c rfid_scan.c rfid_reader.c rfid_reader_spidev.c rfid_reader_rc632_common.c \
rfid_reader_openpcd.c rfid_reader_cm5121.c rfid_reader_cm5121_openct.c rfid_protocol.c \
rfid_proto_tcl.c rfid_proto_tagit.c rfid_proto_mifare_ul.c rfid_proto_mifare_classic.c rfid_proto_icode.c \
rfid_layer2.c rfid_layer2_iso15693.c rfid_layer2_iso14443b.c rfid_layer2_iso14443a.c rfid_iso14443_common.c \
rfid_asic_rc632.c rfid_access_mifare_classic.c libusb_dyn.c

#C files added from utils
LOCAL_SRC_FILES := utils/common.c utils/librfid-tool.c utils/mifare-tool.c utils/send_script.c

#C files added from the src/ccid path
#here we are not using the file rfid_reader_cm5121_ccid_direct.c because it is used by rfid_reader_cm5121.c as 
#reference
LOCAL_SRC_FILES := ccid-driver.c 

#Module path of the library
LOCAL_MODULE := test_rfid_integration_RfidLib
LOCAL_LDLIBS := -llog


include $(BUILD_SHARED_LIBRARY)