interface definition

JavaScript requires class definitions to work. So, you need to create IDL definitions of your scriptable classes. The syntax for the XPIDL is quite standard, so isn’t difficult to create interfaces with this IDL variant. To allow you to use IDL defined interfaces on JavaScript, interfaces must be defined as scriptable and must be derived from nsISupports interface, with an unique uuid. Let me show you an example:

#include "nsISupports.idl"
#include "nsIMyProtocolRequest.idl"
#include "nsIMyProtocolResponse.idl"
#include "nsIMyProtocolError.idl"
#include "nsIMyProtocolStatus.idl"
#include "nsIMyProtocolService.idl"

[scriptable, uuid(3455c51a-3323-4343-844f-2342526113c2)]
interface nsIMyProtocolService : nsISupports
{
    readonly attribute nsIMyProtocolError error;
    nsIMyProtocolResponse get(in nsIMyProtocolRequest req);
    nsIMyProtocolStatus getStatus(in nsIMyProtocolRequest req);
};

This will create a XPCOM object wrapped in JavaScript similar to the following example:

var nsIMyProtocolService = {
    error: new nsIMyProtocolError(),
    get: function (req) {
    },
    getStatus: function (req) {
    },
};

class definition

Here, error is a read only attribute, and get() and getStatus() are methods. But this isn’t enough, that is just the interface definition. The implementation must be done in C++ so the interface defintion is transformed to C++ code — a C++ header specifically — which must be included in the class implementation C++ code file. Where need to consider a special note on class attributes and methods: Every method implementation has the form: nsresult MethodName(…input parameters if any…, …output parameters if any…), where nsresult is the type of the returned status to the XPCOM API to let it know how was executed the method, so you can return NS_OK on execution correctness, NS_ERROR_NULL_POINTER for invalid input as null pointers, NS_ERROR_INVALID_POINTER for invalid variable input and so on. Well, the class definition inside the implementation file, should look as follow:

class nsMyProtocolService : public nsIMyProtocolService
{
public:
    nsMyProtocolService();
    ~nsMyProtocolService();

    nsresult GetError(nsIMyProtocolError **out);
    nsresult Get(nsIMyProtocolRequest *req,
                 nsIMyProtocolResponse **out);
    nsresult GetStatus(nsIMyProtocolRequest *req,
                 nsIMyProtocolStatus **out);
private:
    int statusCode;
    int errorCode;
    char *errorString;
    nsIMyProtocolError *currentError;
}

class implementation

You must be a two star programmer to know how to implement the argument passing and method output, but I know that you are a good C and C++ programmer, so this is not an obstacle and you can act as a three star programmer without problems. So, the implementation, for example for the GetError(), which has been mapped to the error attribute on the nsIMyProtocolService interface, should look as follows:

nsresult
nsMyProtocolService::GetError(nsIMyProtocolError **out)
{
    nsMyProtocolError *rout;
    result = NS_ERROR_NULL_POINTER;
    if (out == NULL || out == nsnull) {
        return result;
    }
    rout = new nsMyProtocolError();
    if (rout == NULL) {
        result = NS_ERROR_NOT_INITIALIZED;
        return result;
    }
    if (currentError != NULL && currentError != nsnull) {
        NS_RELEASE(currentError);
        delete currentError;
    }
    rout->SetErrorCode(errorCode);
    rout->SetErrorString(errorString);
    NS_ADDREF(rout);
    *out = rout;
    result = NS_OK;
    return result;
}

On the example above, we have created a new pointer to the nsIMyProtocolError interface implementation. That pointer, before is being returned to the JavaScript and wrapped by the XPCOM API, must have an increased reference count, so Firefox do not remove that object. But as any language which uses reference counting in its garbage collection tasks, requires a reference counting decrement before the object is released. So you need to release those references using the NS_RELEASE macro. As any software development — with or without a garbage collector behind — you must be careful with the memory usage. Any object with a reference count different from zero, will hang Firefox, so you need to release reference counting on destructors too.

nsMyProtocolService::~nsMyProtocolService()
{
    if (currentError != NULL && currentError != nsnull) {
        NS_RELEASE(currentError);
        delete currentError;
    }
}

The example above shows how the destructor releases the reference counting for the currentError object. But think a little. Every time you call GetError(), in other words, you request the error attribute on the nsIMyProtocolService instance, you are increasing references which are left without being decreased. You need an storage for those pointers, so you can use any collection class that you want and is supported by your platform, but is recommended that you use the kind of storage classes which are present on the XPCOM API. How to create a collection?

nsCOMPtr<nsIMutableArray> container;
container = do_CreateInstance(NS_ARRAY_CONTRACTID);

The nsIMutableArray provides an array class which can be used inside your Firefox extension and also it can be exposed as a JavaScript array, it is an scriptable class, and also provides methods for pushing and extracting elements as the JavaScript array does, so you can use methods such as GetLength(), which is mapped to the length attribute, AppendElement(), which is mapped to the append() method, QueryElementAt() which is mapped to the array[index] operator. The do_CreateInstance template will allow you create instances of you interfaces, when you are requesting them from other extensions. For example if you want to use the WebDAV extension from your C++ extension, you need to use do_CreateInstance template.

component declaration

Finally, you need to register and expose your components to the JavaScript interface and the XPCOM API, so you need to define a contract identifier and add some static code to you extension.

#define NS_MYSVC_CONTRACTID         "@mozilla.org/myprotocol/service;1"
#define NS_MYSVC_CID                                            \
    { /* 3455c51a-3323-4343-844f-2342526113c2 */                \
        0x3455c51a,                                             \
            0x3323,                                             \
            0x4343,                                             \
            { 0x84, 0x4f, 0x23, 0x42, 0x52, 0x61, 0x13, 0xc2 }  \
    }

NS_GENERIC_FACTORY_CONSTRUCTOR(nsMyProtocolService)
NS_DECL_CLASSINFO(nsMyProtocolService)
static const nsModuleComponentInfo components[] =
{
    { "My Protocol Service", NS_MYSVC_CONTRACTID, NS_MYSVC_CID,
      nsMyProtocolServiceConstructor,
      NULL, NULL, NULL,
      NS_CI_INTERFACE_GETTER_NAME(nsMyProtocolService),
      NULL,
      &NS_CLASSINFO_NAME(nsMyProtocolService)
    }
};

NS_IMPL_NSGETMODULE(nsJxSNMPService, components)

This can be used as template, where the components array contains the interface definitions and interface implementation references that allow you to use those classes from JavaScript. This code will:

NS_GENERIC_FACTORY_CONSTRUCTOR

Will declare nsMyProtocolServiceConstructor to be used as default constructor by the do_CreateInstance() template.

NS_DECL_CLASSINFO

Will declare class information referencing the nsMyProtocolService class to allow you to use that class information from JavaScript to be exposed to the XPCOM API.

NS_MYSVC_CONTRACTID

Contract (interface) identifier, it will be required by your JavaScript to instantiate you class, using the interface as was defined in nsIMyProtocolService.

NS_MYSVC_CID

This is the unique uuid identifier for your component. Remember that those components are quite analogous to the COM+ components on the Window$ platform.

NS_IMPL_NSGETMODULE(nsJxSNMPService, components)

This line finally will expose — through static code — your component to the XPCOM API, and will allow your class to being used from JavaScript or your Firefox extension. Remember that components is an array which can hold multiple interface and class definitions.

component exposition

If you followed the article with a conscious reading, the following lines of JavaScript will bring you the proper guide to instantiate your own component. I’m assuming that you are an experienced system programmer and web developer to handle this article:

const C = Components;
const CI = C.interfaces;
const CL = C.classes;

function getContract(contract) {
  try {
    return C.classes[contract];
  } catch (e) {
    alert(e.message);
  }
}

function getService(contract, iface) {
  try {
    return getContract(contract).getService(CI[iface]);
  } catch (e) {
    alert(e.message);
  }
}

function getInterface(contract, iface) {
  try {
    return getContract(contract).createInstance(CI[iface]);
  } catch (e) {
    alert(e.message);
  }
}

try {
    var myService = getService("@mozilla.org/myprotocol/service;1",
                               "nsIMyProtocolService");

    var myRequest = getService("@mozilla.org/myprotocol/request;1",
                               "nsIMyProtocolRequest");

    myRequest.first_argument = 200;
    myRequest.second_argument = "hello world!";
    var myResponse = myService.get(myRequest);
    if (typeof(myService.error) == "object"
        && myService.error.status != 0) {
        alert(myService.error.toString());
    }
} catch (e) {
    alert(e.message);
}

interesting code to look

You can start downloading the Firefox source code and take a look on the following interfaces:

• extensions/webdav, this defines the "@mozilla.org/webdav/service;1" interface, allowing you to create WebDAV clients from JavaScript.
• extensions/webservices, this defines the "@mozilla.org/xmlextras/proxy/webserviceproxy;1," and similar interfaces, allowing you to create WebService client proxies from JavaScript.
• extensions/sql, this folder stores "@mozilla.org/sql/connection;1" and similar interfaces, so Firefox can be used directly as client to query some RDBMS engines — such as PostgreSQL and SQLite.

You can go on deeper reading code and references to enhance your XPCOM component development

references

• "XPCOM", Wikipedia Article, as introductory reading.
• "XPCOM Part 1: An introduction to XPCOM", IBM DeveloperWorks article, by Rick Parrish.
• "XPCOM Part 2: XPCOM component basics", IBM DeveloperWorks article, by Rick Parrish.
• "XPCOM Part 3: Setting up XPCOM", IBM DeveloperWorks article, by Rick Parrish.
• "XPCOM", Mozilla Reference Documentation.

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags:

const_cast operators

If you want an expression to being const, just use the const_cast operator. For example if a legacy function written in C requires of a const argument, just pass a non-const argument by using the const_cast operator:

extern "C" {
    void my_function(const char *p);
};

std::string s = std::string("hello world");
my_function(const_cast<char *>(s.c_str()));

static_cast operator

The static_cast operator performs the conversion unconditionally, without verifying data types at compile time. This makes this operator quite dangerous, so, you need to verify data types before you use variables in this kind of type casting.

if (typeid(*ptr_a) == typeid(MyClass)) {
    ptr_b = static_cast<MyClass>(ptr_a);
    ptr_b->applySomeMethod();
}

You can use the typeid C++ builtin to verify the data type. Also, you must consider that this operator is valid only if the conversion is explicit. Suppose Parent is a base class to Child and that Unrelated is an unrelated class. Then conversions from Child to Parent are valid, but a conversion from Child to Unrelated is disallowed:

Parent a;
Child b;
Parent *a_1 = static_cast<Parent *>(&b); // valid upcast
Unrelated *c_1 = static_cast<Unrelated *>(&b_1); // invalid, Unrelated

The best usage for the static_cast opertaor, are numerical conversions, so you can cast from int, double, float and others of similar type to another int, double, float and similar types, including enum types. Some compilers does this kind of conversion explicit, but more strict compilers usually throw the proper warning on this kinds of assignment, without the proper type casting operation (line 4).

float a;
int b;
a = static_cast<float>(b);
a = b;

dynamic_cast operator

The dynamic_cast operator, among other things, does a runtime check over types applied on the cast operation. As the above example of static_cast operator, dynamic cast does the typeid() checking. Then, if you have a pointer or reference to an object whose declared type is a base class, but you need to obtain a derived class pointer or reference, you should use dynamic_cast, since the dynamic_cast operator is another RTTI (Run-time type information) operator. The use of dynamic_cast derives into more overhead of your program, so you must use it with moderation.

if (ptr_b == static_cast<MyClass>(ptr_a);) {
    ptr_b->applySomeMethod();
}

If the type checking and conversion fails, the operator returns a non-null reference, else it will return a null reference (zero). Also, some compilers will advice on the proper usage of the dynamic_cast operator, the more strict ones, will throw an error.

Parent a;
Child b;
Parent *a_1 = dynamic_cast<Parent *>(&b); // valid upcast
Unrelated *c_1 = dynamic_cast<Unrelated *>(&b_1); // invalid, returns NULL

reinterpret_cast operator

This — possibly — is the most risky to use type casting operator. It completely transforms a pointer to very different types. For example:

some_struct_s {
    short a;
    short b;
};
typedef struct some_struct_s some_struct_t;
some_struct_t *s;
unsigned long v = 0xd34db33f;
s = reinterpret_cast<some_struct_t *>(&v);
std::cout << s->a; // display first 2 bytes of value

As the example above, the pointer was completely transformed to different kind, with the dangerous assumption that the platform has a byte alignment that make possible to access the first to bytes of some address using this kind of operation. This cast is not portable, some compilers should throw some error about it.

The fact is that the reinterpret_cast operator overrides the initial declaration of the given variable, and makes possible to that variable to being reinterpreted as a different one. The usage of the reinterpret_cast must be done careful, for example for derived to base class reinterpretation.

BaseClass a;
DerivedClass *c = reinterpret_cast<DerivedClass *>(&a);

Since many of this kind of conversions are not possible in all compilers, you must try to setup your compiler to the most pedantic flags that it can allow. For example on GCC, you should use -Wall -Wextra -Wshadow -pedantic -std=c++98 as compiler flags. It will keep your code portable and will allow you to create more standarized programs.

Here is a full compiling example of the core ideas in this post:

class A {
public:
	A();
	~A();
};

class B : public A {
public:
	B();
	~B();
};

A::A() {
}

A::~A() {
}

B::B() : A() {
}

B::~B() {
}

int
main(int argc, char **argv)
{

	A *ptr_a = new A();
	B *ptr_b = new B();

	A *a_1 = static_cast<A *>(ptr_b);
	B *b_1 = static_cast<B *>(ptr_a);

	A *a_2 = dynamic_cast<A *>(ptr_b);

	A *a_3 = reinterpret_cast<A *>(ptr_b);
	B *b_3 = reinterpret_cast<B *>(ptr_a);

	const A *a_4 = const_cast<A *>(ptr_a);
	const B *b_4 = const_cast<B *>(ptr_b);

	delete ptr_a;
	delete ptr_b;

	return 0;

}

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags:

daemon configuration

The daemon is quite easy to configure, you must setup the snmptrapd.conf(5snmp) file. For this configuration, you must read your desired configuration options, such as logging and execution. For example if we have a community called inetsnmp, we can configure the file to allow traps from that community and also configure a trap handler written in perl.

# configure inetsnmp community to allow logging,
# execution of handlers and network traffic.
authCommunity   log,execute,net         inetsnmp

# perl embeded handler.
perl do "/usr/share/snmp/handler/trapdembed.pl"

This configuration is not enough, the snmptrapd(8) daemon uses hosts.allow(5) facility, so we need to add the proper rule in that file:

snmptrapd : 192.168.100.0/255.255.255.0 : allow
snmptrapd : 10.10.10.0/255.255.255.0 : allow

the embeded perl handler

#!/usr/bin/perl -w
#

# strict perl is better
use strict;
use FileHandle;
use Data::Dumper;
use NetSNMP::TrapReceiver;

# we create a sample/demo log file...
my $log = FileHandle->new("/var/log/snmptrapsample.log", "a+") ||
    die "Failed to open log file";

# how we process an SNMP variable
sub process_var {
    my ($var) = @_;
    my %res;
    my $name = "$var->[0]";
    my ($vt, $vv) = split /: /, "$var->[1]";
    $res{'oid'} = $name;
    $res{'type'} = $vt;
    $res{'value'} = $vv;
    return \%res;
}

# our default receiver
sub default_receiver {
    my ($pdu, $ivars) = @_;
    my %vars;
    $log->print(Dumper($pdu));
    foreach my $k (@{$_[1]}) {
        $vars{$k->[0]} = process_var($k);
    }
    $log->print(Dumper(\%vars));
    $log->flush;
}

# every OIDs pass through the default_receiver
NetSNMP::TrapReceiver::register("all", \&default_receiver) ||
    die "Failed to laod Sample Trap Receiver\n";

# status message...
print STDERR "Loaded Sample Trap Receiver\n";

This perl(1) handler will allow you basically to create a handler which is capable to process SNMP notifications creating two main variables on the handler itself $pdu which is the reference to the %pdu hash and %vars hash. Both hashes contains the proper data to process the request as you want:

%pdu = {
    'notificationtype' => 'TRAP',
    'receivedfrom' => 'UDP: [10.10.10.1]:53951->[192.168.100.5]',
    'version' => 1,
    'errorstatus' => 0,
    'messageid' => 0,
    'community' => 'public',
    'transactionid' => 1,
    'errorindex' => 0,
    'requestid' => 1012897136
};

%vars = {
    'IF-MIB::ifDescr' => {
        'value' => 'eth0',
        'type' => 'STRING',
        'oid' => 'IF-MIB::ifDescr'
    },
    'IF-MIB::ifAdminStatus.1' => {
        'value' => '1',
        'type' => 'INTEGER',
        'oid' => 'IF-MIB::ifAdminStatus.1'
    },
    'DISMAN-EVENT-MIB::sysUpTimeInstance' => {
        'value' => '(0) 0:00:00.00',
        'type' => 'Timeticks',
        'oid' => 'DISMAN-EVENT-MIB::sysUpTimeInstance'
    },
    'IF-MIB::ifIndex.1' => {
        'value' => '1',
        'type' => 'INTEGER',
        'oid' => 'IF-MIB::ifIndex.1'
    },
    'SNMPv2-MIB::snmpTrapOID.0' => {
        'value' => 'IF-MIB::linkUp',
        'type' => 'OID',
        'oid' => 'SNMPv2-MIB::snmpTrapOID.0'
    },
    'IF-MIB::ifOperStatus.1' => {
        'value' => '1',
        'type' => 'INTEGER',
        'oid' => 'IF-MIB::ifOperStatus.1'
    }
};

Where each OID or variable, can be treated by using the NetSNMP::OID package. Fora stdin handler, if you don’t know about perl(1), the difference is made on the snmptrapd.conf(5snmp) file, instead of configuring a global perl script which itself registers which OIDs will handle, you need to configure a global trap handler or each handler for each OID that you want to handle:

# configure inetsnmp community to allow logging,
# execution of handlers and network traffic.
authCommunity   log,execute,net         inetsnmp

traphandle     default           /usr/share/snmp/handler/defaultstding.py   default
traphandle     IF-MIB::linkUp    /usr/share/snmp/handler/ifuphandler.py     up

This will make your script or application to receive the OID data from stdin as follows:

router
UDP: [10.10.10.1]:37745->[192.168.100.5]
DISMAN-EVENT-MIB::sysUpTimeInstance 0:0:00:00.00
SNMPv2-MIB::snmpTrapOID.0 IF-MIB::linkUp
IF-MIB::ifIndex.1 1
IF-MIB::ifAdminStatus.1 up
IF-MIB::ifOperStatus.1 up
IF-MIB::ifDescr eth0

And also will require that you will enable in some manner the processing of that data as plain text.

Good luck configuring SNMP traps

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags:

named columns

Use named columns, instead of using the * wildcard. For example:

select
    t.*
from
    tbl as t
where
    t.tab_date > current_date - interval 1 month
order by
    t.tab_date desc;

Will be more slower than:

select
    t.tab_id,
    t.tab_state,
    t.tab_date,
    t.tab_name
from
    tbl as t
where
    t.tab_date > current_date - interval 1 month
order by
    t.tab_date desc

join filtering

If you filter on join, your query will be faster, for example:

select
    t1.tab_id,
    coalesce(t2.tab_date, current_date) as tab_date,
    t1.tab_name
from
    table1 as t1
        left join table2 as t2 on (t1.tab_id = t2.tab_tab_id)
where
    t2.tab_date IS NULL or t2.tab_date > current_date - interval 1 month;

Will be more slower than

select
    t1.tab_id,
    coalesce(t2.tab_date, current_date) as tab_date,
    t1.tab_name
from
    table1 as t1
        left join table2 as t2 on (t1.tab_id = t2.tab_tab_id
            and t2.tab_date > current_date - interval 1 month);

smaller set first

The smaller set must selected first, for example:

select
    t1.tab_id,
    coalesce(t2.tab_date, current_date) as tab_date,
    t1.tab_name
from
    table1 as t1
        left join table2 as t2 on (t2.tab_tab_id = t1.tab_id
            and t2.tab_date > current_date - interval 1 month);

Will be more slower than:

select
    t1.tab_id,
    coalesce(t2.tab_date, current_date) as tab_date,
    t1.tab_name
from
    table1 as t1
        left join table2 as t2 on (t1.tab_id = t2.tab_tab_id
            and t2.tab_date > current_date - interval 1 month);

Since t1 has less rows than t2, and t2 is referencing t1. Assuming that t1 has a smaller set of rows and is the referenced table. This applies to column selection too and where statements.

notes

You must measure the time of your queries, so you can have a more precise query. Those rules are not absolute.

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags:

Hello Python Community.

I’m pleased to announce pyxser-1.4.4r, a python extension which contains functions to serialize and deserialize Python Objects into XML. It is a model based serializer. Here is the ChangeLog entry for this release:

1.4.4r (2010.02.10):

        Daniel Molina Wegener 

        * src/include/pyxser_collections.h - added set handling
        function prototypes. Added support for unicode
        key names, which are converted to the user settings
        encoding (ie utf-8) inside the XML output.
        * src/pyxser_serializer.c - removed memory leak. Addded
        support for unicode object names in dictionary/list types.
        * src/pyxser_collections.c - added set handling function
        prototypes. added name property handling algorithm, so
        non string name properties are not serialized. I shall
        extend it to other modules.
        * src/pyxser_tools.c - added set handling prototypes and
        set type checking function.
        * test-utf8-leak.py - added serialization of SQL Alchemy
        objects, so we can test more complex Python objects
        serialization.
        * test-utf8-sqlalchemy.py - added sql alchemy object
        serialization test.
        * src/pyxser_serializer.c - reduced serialization algorithms,
        replacing deep nested if statements by flatten ones.
        * src/pyxser_collections.c - reduced serialization algorithms
        replacing deep nested if statements by flatten ones.
        * src/pyxser_typem.c - reduced serialization algorithms,
        replacing deep nested if statements by flatten ones.

        Thanks to pyxser users for their feedback.

This release contains some bug fixes, mainly related to type checking and type handling. I hope this small extension will help you on your programming tasks.

• The project is hosted at:
  http://sourceforge.net/projects/pyxser/
• The web page for the project is located at:
  http://coder.cl/products/pyxser/
• PyPi entry is:
  http://pypi.python.org/pypi/pyxser/1.4.4r
• For a sample article on how to integrate pyxser with ZSI WebServices:
  http://coder.cl/2009/10/18/pyxser-and-zsi-webservices/

Thanks and best regards…

I hope that this module can help you in your development tasks and thanks for your feedback.

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags:

En conformidad con la Constitución the Debian Project a elegido a Stefano Zacchiroli como nuevo Debian Project Leader para el periodo 2010/2011.
Stefano es Desarrollador Debian desde Marzo del 2001, el contribuye con varios servicios esenciales tales como, Debian’s Package Tracking System y pertenece al Quality Assurance Team. Luego de su elección el declaro: “No puedo estar mas orgulloso de ser un miembro de Debian Project. La cantidad de desarrolladores que tomaron parte de nuestro proceso de elección democrática — candidatos, votantes y participantes de campaña — me hacen muy feliz. Vale decir que estoy un poro asustado ahora, pero puedo asegurar que voy a hacer mi mejor esfuerzo para cubrir las expectativas de todos los colaboradores del Debian Project”.
El project leader saliente, Steve McIntyre, fue electo en el 2008.
Luego de liderar el proyecto por dos años, Steve prefirió no ir por la re-elección.
Steve felicito a Stefano: “Lo e pasado muy bien trabajando para Debian como DPL y estoy mas que feliz seguir trabajando bajo el mando de Stefano.
EL tiene ideas excelentes y realizara un muy buen trabajo.” El proyecto Debian también desea agradecer a Steve por su gran trabajo y sobresaliente compromiso con el proyecto.
Los candidatos de este año fueron Stefano Zacchiroli, Wouter Verhelst, Charles Plessy y Margarita Manterola. Luego de seis semanas de periodo electoral el proyecto Debian eligio a Stefano Zacchiroli para ser su nuevo Debian Project Leader.
Los detalles de las elecciones los puedes encontrar en la siguiente pagina:  votación.?

Hace unas semanas gracias a la ayuda de sarah y ryan he estado trabajando solucionando bugs en el sitio Getpersonas.com (El sitio esta hecho en PHP, y el repositorio usa SVN), esto me ha traído devuelta al mundo de los sistemas de control de versiones (Lo que es genial, por que me gustaba caleta hacer commits, y tener todo ordenado, como cuando trabajaba …)

Cuando ya tenia mis permisos de commit listos para el repo SVN, ryan me recomendó git-svn (Lo que también es genial, por que tenia mas experiencia con Git que con SVN). Así que para aprovechar los bytes de este post, pondre mi setup de Git+SVN, algo del workflow diario y lo ultimo con lo que estuve jugando esta semana: ZSH (Aun estoy amando la integracion con Git).

It’s time to start

Montar el repositorio con Git-SVN

La instalación es muy simple, en Ubuntu basta con un

sudo apt-get install git-svn git-core

Ahora comenzamos a clonar el repo, por ejemplo para el repo de getpersonas en mozilla:

mkdir getpersonas && cd getpersonas

git svn init https://svn.mozilla.org/projects/getpersonas.com/trunk/

git svn fetch -r $REVISION

# (Donde $REVISION es la ultima revision donde se toco la direccion del repo, si le hacen un svn info http://svn.mozilla.org/projects/getpersonas.com/trunk/ veran “Revision del último cambio”. Si quieren le pueden tirar un git svn fetch a secas, pero se bajara TODAS las revisiones del repo svn, osea que si tienen miles y miles de commits, se volveran locos en pocos minutos)

# Si por algun motivo les pasa que se baja la revision, pero los ficheros no aparecen y el git status les dice que hay cambios hechos, y que son ficherros eliminados, intenten dando un

git reset && git checkout .

Con esto ya estamos listos para comenzar a trabajar

Git branchs, patches, merge y commits al server svn

Para trabajar en los bugs, ryan me recomendo usar un branch local de git, para cada bug. Easy cake.

git checkout -b sumario_bug

Y veremos las magicas palabras “Switched to a new branch ’sumario_bug’”, pueden usar cualquier nombre para la branch local, ojala uno descriptivo para acordarse.

Aquí podemos ir realizando los cambios para arreglar el bug (O meter funcionalidades nuevas, el mundo es suyo). Pueden hacer commits al branch, por ejemplo con git commit -a. Con esto listo, podemos usar format-patch y enviar parches:

git format-patch master -o ~/parches/

Este ultimo comando nos generara un parche git, en el directorio ~/parches. Cuando tengamos aprobados los cambios, podemos hacerle un merge con master (la rama principal):

git checkout master

git merge sumario_bug

git svn rebase

Con esto, cambiamos al branch master, hicimos un merge del branch local sumario_bug (Nota aqui, si hicieron mas de un commit en el branch sumario_bug, y quieren que se refleje como solo un commit en SVN, deberan aplicar el switch –squash al git merge), y con el rebase, bajamos los posibles cambios que tenga el repositorio svn y aplicamos nuestros cambios sobre eso (Atentos si hay problemas con el merge que esto provocara). Si no tuvimos ningun problema al hacer el merge y el rebase, o los solucionamos, estamos listos para hacer commit hacia SVN:

git svn dcommit

Que nos pediria los datos del server svn (En este caso, puedo hacer commit por https con mis datos LDAP)

There, estariamos listos para continuar con otro bug.

Para actualizar el repo podemos usar git svn fetch o git svn rebase (El fetch solo baja los cambios, mientras que el rebase intentara un merge si tenemos cambios en la rama local)

Cosas cools, git stash

Otra herramienta genial en git, seria stash, ponganse en este caso, estan trabajando en un branch, tienen harto trabajo hecho y aun no le dan un commit, y llega un bug feo que hay que solucionar ASAP, tendrian que hacer un commit tipo “Dejo guardado el trabajo en esta rama para trabajar en el desgraciado bug feo”; con stash pueden solucionar esto fácilmente:

git stash save "Bug #1234: Cambiar identacion para que el codigo se vea mas lindo"

git checkout master

git checkout -b bug_desgraciado_asap

[...] Terminaron de trabajar en el bug, le dieron commit y todo el cuento, ahora a trabajar en el branch que teniamos antes

git checkout mi_viejo_branch_ya_no_es_lo_que_era

git stash pop stash@\{0\}

Y aplicara los cambios que teníamos antes de trabajar en el bug feo!

Un poco mas sobre stash seria que, no es necesario pasarle un nombre al git stash save, con git stash list listaran los stash que tienen guardados, con git stash show -p stash@\{0\} u otro numero, mostraran el contenido del stash (Noten que el -p viene de git diff, asi que pueden usar cualquier switch del git diff).

Un pager mas bonito

Cuando hacen un git diff, quizas no les guste mucho, si es así pueden usar otro comando para el pager, por ejemplo most:

# ~/.gitconfig

[...]

[core]

pager = most +s +’/—’

[...]

Necesitaran tener most instalado, la otra gracia que hará, será buscar la línea que comience con — (Que es como git define cada cambio, así que automáticamente llegaran al primer cambio en un git diff por ejemplo).

Finalmente, ZSH

El otro dia netkrash nos contaba en irc que estaba usando zsh con los scripts de Oh My ZSH, que tenía completación de nombres para el kill (Onda kill -9 Adi[tab] buscaba el proceso con ese nombre y extraia el pid), completación de hostnames para ssh|scp, y lo que mas me intereso, integración con git … cuando leí eso ultimo lo instale altiro!

Bueno, la instalacion de ZSH es bien simple:

sudo apt-get install zsh

Luego pueden instalar oh my zsh, el instalador automático bastara (Nota para algunos, NECESITAN tener instalado zsh antes de oh my zsh, aviso por si las moscas …):

wget http://github.com/robbyrussell/oh-my-zsh/raw/master/tools/install.sh -O - | sh


Y ya estan listos, si quieren meter mano en los configs de oh my zsh, pueden hacerlo en .oh-my-zsh. Al momento tengo algunos cambios en mi branch local:

• Desactivar el menu de zsh (Para la autocompletacion, me acostumbre al completado como en bash) (Thanks netkrash)
• Completacion de hosts ssh|scp segun ~/.ssh/config en vez del known_hosts (Netkrash again)
• Completacion de usuarios con uid superior a 1000 (Comunmente usuarios reales), mostrar a root y ocultar a nobody.
• El atajo de oh my zsh de git diff (gd), se le pasa mate por un pipe, quite eso por que ya tengo un pager configurado.
• Trackear los ficheros de custom/
• Tema ‘idk’ para zsh (Para cambiar los temas de zsh basta con cambiar la variable ZSH_THEME en su ~/.zshrc), basado en macovsky y wezm (Incluidos en oh my zsh). Preview.

En fin, si les interesan los cambios, en este tar vienen todos los patches que he aplicado (Pueden crear un branch en .oh-my-zsh con git checkout -b mismods y luego aplican los parches con git am nombreparche.patch)

Me faltaron un poco de fuentes, Viget entregaba un par de tips, muy buenos.

dpkg-reconfigure tzdata

Con esto aparecerá un asistente que permite realizar el cambio de forma bastante sencilla. Para el caso de Chile, este 2010 se ha optado por prolongar el cambio de horario hasta abril, de ahi la necesidad de ajustar la zona a una diferente.

Ante esa situación y considerando que era un apartición /home/ el procedimiento seguido fue el siguiente:

tener claridad de que particiones componen el arreglo, en este caso /dev/sda3 y /dev/sdb3

Revision de particiones por separado.

fsck.ext3 /dev/sda3

fsck.ext3 /dev/sdb3

Volver a incorporar el raid al sistema

mdadm – -assemble /dev/md3 /dev/sda3 /dev/sdb3

Revisión del Raid armado

fsck.ext3 /dev/md3

Incorporar nuevamente los arreglos al mdadm.conf

mdadm – -detail – -scan >> /etc/mdadm/mdadm.conf

Con esto los arreglos quedaron funcionales

Como Documentación personal dejo registro de algo que he hecho en otras oportunidades, pero de lo cual no siempre recuerdo todos los parámetros.

Para quien lea éste artículo, daré solo algunas pautas esenciales para la implementación del protocolo SSL sobre plataformas WEB y el uso de certificados auto firmados.

OBJETIVOS

UTILIDAD DE UN SITIO HTTPS

Quien no sea muy entendido, podrá desconocer que cuando son insertados datos dentro de formularios de sitios que solamente usan http, estos datos son enviados en texto claro por la red y pueden ser capturados y utilizados de manera maliciosa por cualquiera que tenga acceso a los equipos de comunicaciones por donde pasan estos datos.

REQUISITOS DE UN SITIO VÄLIDO

Para que un sitio sea reconocido como un sitio seguro válido, debe cumplir con 3 condiciones esenciales:

CERTIFICADOS AUTO FIRMADOS

Cuando se utilizan certificados, estos deberían ser firmados por una entidad reconocida ( C A ) como lo es verisign. Los navegadores tienen registrados una gran cantidad de entidades reconocidas dentro de lo que se conoce como Entidades Raiz de Confianza. Cuando un administrador de sistemas decide generar por si mismos los certificados y también firmarlos, se produce una advertencia por parte del navegador, indicando que la entidad emisora que ha firmado el certificado no es de confianza y que puede tratarse de un certificado inválido o un sitio falsificado.

La manera correcta de habilitar un sitio auto firmado consiste en generar los certificados, firmarlos y hacer que los clientes reconozcan al equipo que los firma como una CA válida dentro de los certificados raíz de confianza

EMISION Y FIRMA DE CERTIFICADOS

A continuación la forma de emitir certificados para la CA y un sitio web utilizando Linux, apache2 y openSSL. ( Fuente Original )

Generando Certificados para la CA.

En mi caso, voy generar una Entidad Emisora de Certificados Llamada zamoranelson.cl, por lo que he de generar los certificados y llaves correspondientes llenando los datos solicitados por openSSL.

Creamos un directorio llamado / etc / apache2/ssl y ejecutamos los siguientes comandos.