log file when the script fails !

i have a script that will retrive some info from database. The script is working fine but i have to add new feature in it when the script fails or retrive null result it should reflect in the log file. below the script AMR_Inactive.sh Code: --------- while read i do

Categories: Computers | Linux | nix | The UNIX and Linux Forums | UNIX

phpDiveLog 0.3.1 (Default branch)

Image: http://c.fsdn.com/fm/screenshots/47640_thumb.png phpDiveLog displays the information of your Aqua DiveLog LogBook based on CSV files you generate with the Java Conduit shipped with Aqua DiveLog. These dynamic pages are nicely and lucidly formatted. phpDiveLog allows you to combine these...

Categories: Computers | Linux | nix | The UNIX and Linux Forums | UNIX

On event processing and some interesting queries

2009-01-05T23:45:00.017+02:00 Image: http://4.bp.blogspot.com/_2ExAgtF_Qgk/SWKCG4EgrgI/AAAAAAAAAVk/IYCt6w6oXHc/s320/Fish_market_Guadeloupe.jpg (http://4.bp.blogspot.com/_2ExAgtF_Qgk/SWKCG4EgrgI/AAAAAAAAAVk/IYCt6w6oXHc/s1600-h/Fish_market_Guadeloupe.jpg)Some people have returned from the vacation...

Categories: Computers | Linux | nix | The UNIX and Linux Forums | UNIX

VNC "Access Denied"

Hi guys, I am having a problem with my VNC, Actually i am using my VNC session for last two month. but now it's show me the "Access denied" when i am trying to access it. I checked the logs, then i found it has blacklisted by server. error is something like "Connections: rejecting blacklisted...

Categories: Computers | Debian | Fedora | Gentoo | Linux | Mandriva | nix | RedHat | Slackware | SUSE | The UNIX and Linux Forums for Linux | Ubuntu

Formatting digits

I want to check the argument in KSH. If the user type in the prompt 'find 3' it will format 3 to 003 to match the data in the text file. Same as with 10 to 010. Always begins with 0. eg. >find 3 Output: 003 >find 30

Categories: Computers | Linux | nix | The UNIX and Linux Forums | UNIX

Jono Bacon: I Invented Twitter

Well kind of…in a way…possibly…OK, not at all.

The other day I was digging through some old articles that I wrote. To my amusement, I saw a reference to a little program I hacked up once when I was involved as a KDE developer. I had totally forgotten about it, and I figured it would be fun to share the story.

Back in the year 2000 when I was starting University, I spent every evening between midnight and 6am hacking on code. Fuelled by six cans of coke every night, I barely slept for those few years: I was running on three or four hours of sleep for most nights. Every evening I was excited to fire up my concrete brick of a laptop, check out the latest KDE CVS and taste the latest crack of the day. This inspired me to want to contribute to the project in some way.

It was a bit of a trial by fire. I was not only learning C++ but also Qt and the KDE bindings. To be frank, I was not very good. But I tried hard, I learned a lot, and mostly importantly, I had a lot of fun.

Throughout this time I wrote a bunch of little programs. One of these programs was called KWebStat, and this what I re-read about the other day. Using the wonder of the Wayback Machine I managed to find the old homepage for it which included a screenshot:

See a bigger screenshot

When I read the article, I realised the program was a simple, primitive equivalent to what we now know as Twitter: it put a current status update online. KWebStat was a little different: instead of writing a message, you could click some buttons to indicate what you were doing at that moment, and you could set custom activities to show. KWebStat was a lot more primitive than Twitter though: it updated a static HTML page and you needed some magic to get that page online, but the basic premise was there. There were a few niceties though: KWebStat could grab which song you were listening to in your CD or music player as well as grab a screenshot and put that online. It was a pretty primitive first implementation of status-blogging, and I used it on my old homepage.

So, if the Twitter folks would kindly send over a portion of that mountain of gold that they have, it would be appreciated.

Hugs, Jono.

Categories: Computers | Linux | nix | Planet Ubuntu | Ubuntu

Ted Gould: Let applications be applications

One thing that kept bothering me in the GNOME UI Hackfest was how little data applications export out to the desktop. As I was in the shell group we were discussing various things that we wanted to do and John Mccann kept having to remind me not to worry about the implementation as I would get frustrated that we simply didn't have the data. I want to fix this. I want to have the data in a structured way.

What I've come to realize is that we need to let applications be applications, let panels be panels and let applets be applets. With the notification area specification we created a way for applications to break through this barrier and put a little segment of the application into the panel. While this sounds great, and it has created a quick way to prototype some interesting ideas, it's also created a complete mess in our panels. There is no consistency of action nor in look for that section of the panel. I like to call the notification area the "bag of crap." While it's created a way for applications to innovate, it's drastically stalled innovation for panels and shells.

What I'd like to put forward is the idea of little flags that applications can hold up to say what they're thinking or doing, which I'm going to call indicators. The application can then represent in a structured way that it's got something of interest to the desktop as a whole, and then the desktop can represent that to the user. How ever it likes. It's not the application's responsibility to figure out how to do this, or if it needs to be done in a single place or multiple, or anything other than raising the flag. While I think that this might frustrate application developers at first in that they don't have control over the display of this information, I think that long term it will empower them in that they don't have to fiddle with this type of interaction any more.

First off I want to build something simple (start small, think big), the messaging indicator, which will mostly consist of a GNOME panel applet. It will do simple things like represent IMs and e-mail and not a lot more, but the real goal is starting to get applications like Evolution and Pidgin to export this information. Once we're there, then we can start to look at new ways to use it. I love the idea of having the Evolution icon having the number of unread messages a la Apple or Gwibber also putting messages in the messaging indicator. Those are all next steps, but I think important ones in starting to explore how we can get data out of the applications and to the users in usable and attractive ways.

Categories: Computers | Linux | nix | Planet Ubuntu | Ubuntu

James Henstridge: Using Twisted Deferred objects with gio

The gio library provides both synchronous and asynchronous interfaces for performing IO.   Unfortunately, the two APIs require quite different programming styles, making it difficult to convert code written to the simpler synchronous API to the asynchronous one.

For C programs this is unavoidable, but for Python we should be able to do better.   And if you’re doing asynchronous event driven code in Python, it makes sense to look at Twisted.   In particular, Twisted’s Deferred objects can be quite helpful.

Deferred

The Twisted documentation describes deferred objects as “a callback which will be put off until later”.   The deferred will eventually be passed the result of some operation, or information about how it failed.

From the consumer side, you can register one or more callbacks that will be run:

def callback(result):
    # do stuff
    return result

deferred.addCallback(callback)

The first callback will be called with the original result, while subsequent callbacks will be passed the return value of the previous callback (this is why the above example returns its argument). If the operation fails, one or more errbacks (error callbacks) will be called:

def errback(failure):
    # do stuff
    return failure

deferred.addErrback(errback)

If the operation associated with the deferred has already been completed (or already failed) when the callback/errback is added, then it will be called immediately. So there is no need to check if the operation is complete before hand.

Using Deferred objects with gio

We can easily use gio’s asynchronous API to implement a new API based on deferred objects.   For example:

import gio
from twisted.internet import defer

def file_read_deferred(file, io_priority=0, cancellable=None):
    d = defer.Deferred()
    def callback(file, async_result):
        try:
            in_stream = file.read_finish(async_result)
        except gio.Error:
            d.errback()
        else:
            d.callback(in_stream)
    file.read_async(callback, io_priority, cancellable)
    return d

def input_stream_read_deferred(in_stream, count, io_priority=0,
                               cancellable=None):
    d = defer.Deferred()
    def callback(in_stream, async_result):
        try:
            bytes = in_stream.read_finish(async_result)
        except gio.Error:
            d.errback()
        else:
            d.callback(bytes)
    # the argument order seems a bit weird here ...
    in_stream.read_async(count, callback, io_priority, cancellable)
    return d

This is a fairly simple transformation, so you might ask what this buys us. We’ve gone from an interface where you pass a callback to the method to one where you pass a callback to the result of the method. The answer is in the tools that Twisted provides for working with deferred objects.

The inlineCallbacks decorator

You’ve probably seen code examples that use Python’s generators to implement simple co-routines. Twisted’s inlineCallbacks decorator basically implements this for generators that yield deferred objects. It uses the enhanced generators feature from Python 2.5 (PEP 342) to pass the deferred result or failure back to the generator. Using it, we can write code like this:

@defer.inlineCallbacks
def print_contents(file, cancellable=None):
    in_stream = yield file_read_deferred(file, cancellable=cancellable)
    bytes = yield input_stream_read_deferred(
        in_stream, 4096, cancellable=cancellable)
    while bytes:
        # Do something with the data.  For this example, just print to stdout.
        sys.stdout.write(bytes)
        bytes = yield input_stream_read_deferred(
            in_stream, 4096, cancellable=cancellable)

Other than the use of the yield keyword, the above code looks quite similar to the equivalent synchronous implementation.   The only thing that would improve matters would be if these were real methods rather than helper functions.

Furthermore, the inlineCallbacks decorator causes the function to return a deferred that will fire when the function body finally completes or fails. This makes it possible to use the function from within other asynchronous code in a similar fashion. And once you’re using deferred results, you can mix in the gio calls with other Twisted asynchronous calls where it makes sense.

Categories: Computers | Linux | nix | Planet Ubuntu | Ubuntu

Hammock 1.5 (Default branch)

Hammock is a mock object framework for J2ME devices. It is used in conjunction with unit test frameworks like JMUnit and J2MEUnit. The framework includes mocks for many of the J2ME UI and I/O classes as well as a utility, HammockMaker, for generating mocks of other classes. *License:* The Apache...

Categories: Computers | Linux | nix | The UNIX and Linux Forums | UNIX

checksysreport 1.0-4 (Default branch)

Image: http://c.fsdn.com/fm/screenshots/61865_thumb.jpg checksysreport performs some automatic tests against a directory containing an untarred Red Hat Enterprise Linux sysreport. You will need a valid Red Hat Network login in order to use it, as it fetches information from RHN using the RHN API...

Categories: Computers | Linux | nix | The UNIX and Linux Forums | UNIX