LargeEntity

Crear host virtual Apache – Nginx

Apache y Nginx los servidores web mas usados en la web de hoy dia, cada uno con sus ventajas y desventajas ( Este no sera un post para nombrarlas ).

Este tutorial es para cuando la necesidad de poder hostear mas de un site en un mismo servidor y necesitamos que cada uno responda a un dominio distinto, el proceso es bien simple y facil.

Apache

Los archivos vhost estan situados en directorios distintos segun el sistema operativo:

Vhost File
  • Si estan usando wamp estan en la caperta bin/apache/conf/extras/vhost
  • Ubuntu, /etc/apache2/site-avaliable
  • centos /etc/httpd/conf.d
Conf file
  • Si estan usando wamp estan en la caperta bin/apache/conf/httpd.conf
  • Ubuntu, /etc/apache2/httpd.conf
  • Centos /etc/httpd/conf/httpd.conf

Una vez localizados estos archivos es necesario comprobar algunas configuraciones

  • Asegurar que no este comentado esta opacion Include conf.d/*.conf
  • Asegurar que esta opcion no este comentada tampoco NameVirtualHost *:80

Luego de haber configurado nuestro http.conf y localizado donde colocar los vhost files proceder a crearlos.

Ejemplo 1:

Este vhost servira para cuando accedan a dominio.com el projecto a mostrar seria el de la carpeta /carpeta_to_projecto/

    Listen 80

   <VirtualHost *:80>
        DocumentRoot /carpeta_to_projecto/
        ServerName dominio.com
    </VirtualHost>
Ejemplo 2:

Con este ejemplo podran hacer lo mismo que en el anterior con la salvedad de que este si identifica los enlaces simbolicos ( FollowSymLinks ) y les permitiras listar los archivos de una carpeta ( Options Indexes ),la opcion de AllowOverride all es muy usada por muchos frameowrks php para crear sus rutas si esta ocion no existe su framework no podra funcionar chevere.

    Listen 80

    <VirtualHost *:80>
        DocumentRoot /var/www/test_project/
        ServerName projecto.com

        <Directory /var/www/test_project>
            AllowOverride all
            Options Indexes FollowSymLinks
        </Directory>
    </VirtualHost>

Luego de crear sus vhost files es cuestion de reiniciar el servicio de apache y todo estara funcionando (Si todo le sale bien).
**Los vhost files deben guardarce con extencion .conf sino apache no sabra que son vhost.conf

Nginx

Los archivos vhost en nginx esta situados en /etc/nginx/conf.d/ a menos que estes en uguntu estaran en /etc/nginx/sites-available/ (Tenia que ser un ubuntu :/ ).

Ejemplo 1:

El atributo location es muy usado para algunos frameworks que necesitan ubicar la direccion de los archivos estaticos (.js/.css/.imgs).

	server {
	        listen   80;
	        
	        root /var/www/projecto;
	        index index.html index.htm;

	        server_name nightdeveloper.net;

                location / {
                    try_files $uri $uri/ =404;
                }
	}

Referencia Nginx
Referencia Apache

Como manejar procesos nodejs con PM2

Subir procesos y bajar procesos en un sistema linux puede ser suficiente para poner en ejecución un server nodejs y es cool en algunos casos se siente bien ejecutar kill PID para detener procesos pero luego de un tiempo no es tan cool.

Esto “podria” ser suficiente para subir/ejecutar un server nodejs.


node server.js > stdout.txt 2> stderr.txt &

Pero que tal si con solo ejecutar

pm2 start server.js --name ServidorUno

Bueno PM2 es una alternativa a tener que manejar a mano esto de los servidores nodejs y es una alternativa mas a Node for Ever que es mejor que la primera pero se queda algo corta en comparación con PM2. PM2 nos brinda la opción de poder crear balanceadores de carga a nuestra aplicación sin alterar nuestro código el por si solo realiza todo el trabajo sucio detrás de escenas.

Entre sus Principales características podrían destacarse las siguientes:

-Capacidad de manejar un sin numero de apps. ( Ver el estado de distintas apps )
-Capacidad de monitoreo de memoria y cps de nuestros procesos.
-Manejo de logs. ( Cosas que imprimimos en nuestros procesos son mostrados ahi )
-Balanceo de cargas ya mencionado.
-Iniciar tus aplicaciones una vez el servidores se inicia.
-Capacidad de “watch your code” si tu codigo cambia.

este reiniciara el proceso, bien util a la hora de hacer pases sin tener down time.

Ejemplos de iniciar aplicaciones:

La forma de iniciar las aplicación tambien las registrara en la interface de pm2, por lo que solo se iniciara una sola vez de esta forma, luego seria pm2 start [id]|[name]

#ejemplo simple de como iniciar un proceso.
pm2 start server.js 

#iniciara el servidor con 3 procesos
pm2 start server.js -i 3

#inicia el servidor con el máximo numero de procesos posibles
pm2 start server.js -i max

#darle un nombre al proceso ( Esto es para manejarlo por nombre y olvidar el pid )
pm2 start server.js --name HelloServer

#pasar parámetros al iniciar el servidor
pm2 start server.js --node-args="--param=val -d"

#iniciar aplicación observada ( observa cambios en el file system )
pm2 start server.js --watch

Manejo de una aplicacion


pm2 start server.js --name=server-uno

pm2 restart server-uno

#eliminara server-uno de la interface de pm2
pm2 delete server-uno 

#eliminara a todas las aplicaciones ya registradas
pm2 delete all

Comandos de utilidad

#creara un init-script y se ejecutara cada vez que el servidor inicie.
pm2 startup [ubuntu|centos|systemd]

#mostrara todas las aplicaciones registradas
pm2 list

#recargara una aplicación
pm2 reload api

#mostrara los logs de todas las aplicaciones ya corriendo.
pm2 logs

#mostrara logs de la aplicación
pm2 logs appName
#guardara todos los cambios realizados con pm2 ( inicio de aplicación y demás configuraciones )
pm2 save

pm2 list

pm2_list

pm2 desc

pm2_description

pm2 monit

pm2_monitoring
si este projecto les gusto les recomiendo este para un entorno de desarollo Nodemon super facil de usar.

Repositorio y documentación del Projecto

Android Push Notification ( Parte 1 – Cliente )

Las Notificaciones push son por hoy una de los mejores features (Opino yo) que han tenido los móviles, ya que le da al developer la opción de poder interactuar de la manera que quiera con el usuario final y poder así brindarle un buen producto de calidad y una buena experiencia.

Desde enviarle una notificación de un chat o mail hasta hacer que su celular se comporte de forma que el developer quiera (Evil inside).

Hoy dia hay varias alternativas para poder implementar las notificaciones push desde proveedores terceros hasta el mismo google con GCM (Google cloud message) y el que estaremos usando para este tutoriral.

Ahora mismo un poco de la interacciones que suceden para poder llevar acabo esto.

Flow Interation

 

 Detalles de las interacciones

Paso 1 & 2:

Desde el móvil la aplicación se conecta al CGM y solicita un identificador.

Paso 3:

Desde la aplicación buscamos la manera de almacenar ese identificador retornado por GCM. Digo la manera por que el hecho es que el identificador se genero y depende de nosotros guardarlo.

Paso 4:

Desde nuestro servidor de aplicación enviamos las peticiones al GCM para que este luego procesa a enviar los push al dispositivo especifico.

 

Antes de comenzar a coder debemos primero realizar los siguientes pasos.

1.Antes de comenzar debemos crear un projecto en el Google console Developer.

Google_Developers_Console

2.Luego debemos agregarle la api de Google Cloud Message a nuestro Projecto

Google_Developers_Console_api

3.Generar una key para nuestro projecto.

Google_Developers_Console_server_keyGoogle_Developers_Console_ip_key

 

 

Una vez hecho todo Esto, Mano en el codigo.

Crear un projecto Android Simple.

Incluirle el google-play-service-lib

Agregar estos permisos a nuestra applicacion.

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="com.google.android.providers.gsf.permission.READ_GSERVICES" />
    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />

Dentro del tag de application agregar esto, sino les dara un error.

    <meta-data
            android:name="com.google.android.gms.version"
               android:value="@integer/google_play_services_version" />

Luego agregar este permiso especial, y cambiar “com.example.projecto” por el propio.

    <permission
        android:name="com.example.projecto.permission.C2D_MESSAGE"
        android:protectionLevel="signature" />

Luego debemos crear un Servicio android que extienda de IntentService, el servicio estara encargado de generar una notificacion una vez reciba un push notificacion de GCM.

public class GCMService extends IntentService{

    private NotificationManager mNotificationManager;

    private int NOTIFICATION_ID = 1234;

	public GCMService() {
		super("Listener-Service");
	}

    @Override
    protected void onHandleIntent(Intent intent) {
        Bundle extras = intent.getExtras();

        sendNotification("Received: " + extras.toString());

        GCMBroadCastReceiver.completeWakefulIntent(intent);
    }

    private void sendNotification(String msg) {
        mNotificationManager = (NotificationManager)this.getSystemService(Context.NOTIFICATION_SERVICE);

        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,new Intent(this, MainActivity.class), 0);

        NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
        											.setSmallIcon(R.drawable.ic_launcher)
											        .setContentTitle("Developer")
											        .setStyle(new NotificationCompat.BigTextStyle()
											        .bigText(msg))
											        .setContentText(msg);

        mBuilder.setContentIntent(contentIntent);
        mNotificationManager.notify(NOTIFICATION_ID, mBuilder.build());
    }
}

Agregar el servicio que acabamos de crear a nuestro manifest.xml.

<service android:name="com.example.deveoper.GCMService" />

Ahora necesitamos crear un receiver para poder recibir las notificaciones.

public class GCMBroadCastReceiver extends WakefulBroadcastReceiver{

	private String TAG = "Broadcast receiver";

	@Override
	public void onReceive(Context context, Intent intent) {
		ComponentName comp = new ComponentName(context.getPackageName(),GCMService.class.getName());

        startWakefulService(context, (intent.setComponent(comp)));

        setResultCode(Activity.RESULT_OK);

        Log.i(TAG,"Notification receive");
	}
}

Agregar el receiver que acabamos de crear en nuestro archivo manifest.xml

        <receiver
            android:name="com.example.developer.GCMBroadCastReceiver"
            android:permission="com.google.android.c2dm.permission.SEND" >
            <intent-filter>
                <action android:name="com.google.android.c2dm.intent.RECEIVE" />

                <category android:name="com.example.developer" />
            </intent-filter>
        </receiver>

Una vez esten creado nuestro servicio y nuestro receiver procedemos a trabajar sobre la actividad donde estaremos solicitando nuestro “client-id”.

En este ejemplo usare el main activity pueden usar cualquier actividad. Nuestra mainActivity estaria quedando de esta forma.

public class MainActivity extends Activity {

	private final static int PLAY_SERVICES_RESOLUTION_REQUEST = 9000;

	private GoogleCloudMessaging gcm = null;

	private String SENDER_ID = "tu-project-id";
	private String regid;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		if( checkPlayServices(this) == true ){
			getReigstrationId(this);
		}
	}

	public void getReigstrationId(final Context context){
		new AsyncTask<Void, Void, Void>(){

			private String msg;

			@Override
			protected Void doInBackground(Void... arg0) {

				if (gcm == null) {
	                gcm = GoogleCloudMessaging.getInstance(context);
	            }

	            try {
	            	Log.i("Sender",SENDER_ID);

					regid = gcm.register(SENDER_ID);

					msg = "Movil registrado, registration ID=" + regid;

				} catch (IOException e) {
					e.printStackTrace();
				}

				return null;
			}

			@Override
			protected void onPostExecute(Void result) {

				Log.i("Developer",msg);
				Toast.makeText(context, msg, Toast.LENGTH_LONG).show();
			}
		}.execute();
	}

	public static boolean checkPlayServices(Context context) {
	    int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(context);
	    if (resultCode != ConnectionResult.SUCCESS) {
	        if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
	            GooglePlayServicesUtil.getErrorDialog(resultCode, (Activity) context,PLAY_SERVICES_RESOLUTION_REQUEST).show();
	        } else {
	            Log.i("Developer", "This device is not supported.");
	        }
	        return false;
	    }
	    return true;
	}
}

Si todos los pasos le salieron bien, tendrían como resultado un Toast con su “registratio-id” el cual es el que se usa para enviar las notificaciones.

Hasta aqui la primera parte de este tutorial.

Repositorio con el ejemplo completo

Google Cloud Meesage

Android Push Notification ( Parte 2 – Productor ) ( Python )

Hola que tal, esta es una segunda parte de tutorial sobre notificaciones push con android.

Android Push Notification (Parte 1 – Cliente)

En esta entrega estaremos continuando y creando el productor ( Quien genere las notificaciones para GCM ).

Los requerimientos para este tutorial son simple, solo necesitas isntalar la libreria Requests de python para poder realizar los request a GCM.

pip install requests

ahora bien para probar pueden utilizar este simple ejemplo ejecutando este archivo y estarán enviando notificaciones a los “registration-id” que le suplan.

import requests
import json

#Estos son los parametros extra para enviar y recibirlos por extras en el intent del receiver
extra = {"param1":"valor parametro 1","param2":"valor parametro 2"}
dataRaw = {
			"data":extra,
    		"registration_ids":[
    			#Los registration ids a cuales les enviara la notificacion
				'registration-id',

            ]
        }
key = "your server key generated"

headers = {
	"Content-Type":"application/json",
	"Authorization":"key={}".format(key)
}

result = requests.post("https://android.googleapis.com/gcm/send",headers=headers,data=json.dumps(dataRaw))

print result.text
print result

Si todo sale bien tendran un resultado como este

{"multicast_id":4616697826678564758,"success":1,"failure":0,"canonical_ids":0,"results":[{"message_id":"0:1402514025648966%2fee3519f9fd7ecd"}]}
<Response [200]>

Screenshot (03-10PM, Jun 11, 2014)

 

Si quieren mas referencia a la libreria request he aqui un tutorial de como usarla.
Request Python Referencia

Generar un Codigo QR Dotnet ( C# )

Hola,

Hoy dia casi todos los celulares tienen la característica de poder leer códigos QR en la web se comparten muchas cosas con los mismo, desde links a paginas, códigos de productos para almacenarlos, en fin muchas cosas (La mayor parte son links de urls), en internet hay muchísimas paginas las cuales pueden ser usadas para generar dichos códigos QR otras ofrecen apis para consumirlas y generalas pero eso no es cool el tener que consumir una api para poder generar un simple código QR.

En este modelo los clientes serian los mobiles los cuales son los que leen los codigos QR y de alguna manera el productor es quien los genera, ahora bien esta vez estaremos genrando los codigos QR con dotnet y la libreria ZXing (Port para dornet) que la misma tiene bastantes ports a diferentes plataformas.

Primero debes descargar la libreria desde el manejador de paquetes NUGET

Consola nuget

PM> Install-Package ZXing.Net

Aqui el codigo.


            // Lo primero es crear un objecto escritor para generar el codigo QR
            var writer = new BarcodeWriter() // Si un barcodeWriter para generar un codigo QR (O.O)
            {
                Format = BarcodeFormat.QR_CODE, //setearle el tipo de codigo que generara.
                Options = new EncodingOptions() {
                    Height  = 300,
                    Width   = 300,
                    Margin  = 1, // el margen que tendra el codigo con el restro de la imagen
                },
            };

            // Generar el codigo, este metodo retorna una bitmap
            Bitmap bitmap = writer.Write(value); 

             // guardar el bitmap con el formato deseado y la locacion deseada
            bitmap.Save( String.Format("c:\\"+ "{0}.png",value) , ImageFormat.Png);

 
 
 
 

Referencia

Zxing (GITHUB)

Zxing (CodePlex)

Construir Una Api rest con Flask ( Python )

Hoy dia se hace tarea ordinaria el tener que crear una api rest para ser consumida por alguna terminal ya sea web o movile, teniendo tantas herramientas para poder crearlas la parte difícil es decidir que usar para realizarlas “Right tool for the right job“. Por lo que en este tutorial estaremos crenado una api rest con flask.

Flask

Es un micro web framework construido sobre el poderoso python y sus ideales. Es un micro framework por que no incluye un ORM nativamente pero el mismo te la facilidad de poder integrarlo con casi cualquier herramienta, sin mencionar la gran cantidad de plugins que la comunidad ha desarrollado para el mismo.

Una de las caracteristicas de Flask es lo simple y facil que es de usar (Como todo en python) y crear lo que quieres en cuestion de segundos.

Hola Mundo con Flask

##
    from flask import Flask
    app = Flask(__name__)

    @app.route("/")
    def hello():
        return "Hello World!"

    if __name__ == "__main__":
        app.run()

##from home page doc - http://flask.pocoo.org/

El objetivo de este tutorial no es abundar en las maravillas de este framework, es mas para crear una api rest y eso haremos acontinuacion.
Nuestra aplicacion base sera la siguiente

    ##
        from flask import Flask
        import json

        app = Flask(__name__)

        ## los metodos iran luego de esta linea

        if __name__ == "__main__":
            app.run(debug=True,port=8888)
    ##

Simple json response para un servicio

    ##
        @app.route("/")
        def hello():

            data = {"api":"rest :)"}

            return json.dumps(data)
    ##

El ejemplo anterior muestra un simple servicio rest que retorna un json con una key llamada Api.
Ahora digamos que queremos hacer un metodo de login para nuestra app. Tendriamos algo como esto, donde el cliente envia data serializada donde tiene el usuario y la clave. Para esto el metodo debe de ser post y agregarle el header Content-Type: application/json para que el framework pueda parsear la data a json ( y luego a un Diccionario)

    ##
        from flask import request

        @app.route("/auth/login",methods=['POST'])
        def log_auth():

            values = request.get_json()

            return json.dumps(values)
    ##

Una vez Ejecutado esto repondera los valores enviados posteriormente, esto ultimo con motivos de prueba y ver como obtener los valores enviados por el cliente.

Metodo login completo y validando valores para realizar login

    ##
        from flask import request

        @app.route("/auth/login",methods=['POST'])
        def log_auth():

            values = request.get_json()

            if values['usuario'] == 'admin' and values['clave'] == 'top_secret':
                respuesta = {'error':False,'mensaje':'Auser logged'}
                return json.dumps(respuesta)

            respuesta = {'error':True,'mensaje':'Fail Auth'}
            return json.dumps(values)
    ##

Una vez el metodo relizado correctamente y el cliente haber enviado los valores correctamente tendriamos una respuesta como esta.

    //
        {
            "mensaje": "Auser logged",
            "error": false
        }
    //

En este servicio estare mostrando como seria realizar un request GET pidiendo todos los post digamos que de un blog.

    ##
        @app.route("/app/api/post",methods=["GET"])
        def api_post():

            data = []

            for i in range(10):
                #Generamos un poco de contenido
                data.append( {
                    "titulo":"titulo",
                    "detalles":"Lorem Ipsum has been the industry's standard dummy text ever since the 1500s",
                    "tags":["android","nodejs","javascript"]
                    } )

            return json.dumps(data)
    ##

En este Servicio seria una peticion tipo GET pero pasando parametros por la url pero con url amigables, podria funcionar con un query String pero este es un feature del framework (Es bien abundante este features en otro frameworks).

    ##
        @app.route("/app/api/post//",methods=["GET"])
        def details_post(id):

            data = {
                "titulo": "titulo {} ".format(id),
                "detalles":"Lorem Ipsum has been the industry's standard dummy text ever since the 1500s",
                "tags":["android","nodejs","javascript"]
            }

            return json.dumps(data)
    ##

Flask Home page

Saludos,

Consumir API json con Android

Hola que tal, Buenas. En esta entrega estaré realizando un tutorial de como consumir una api json con android, estaré trabajando con los recursos nativos de android, ósea nada de librerías de terceros por el momento.

Para realizar peticiones http estaremos usando las clases HTTPGet y HTTPPost ademas de los helpers para json JSONArray y JSONObject.

Dejaremos detras la creacion del projecto y todo lo demas relacionado con el projecot android, al final del dia no es el objetivo en este tutorial.

Digamos que tenemos una api  “http://localhost.dev/country” que acepta metodos get para retornar una lista de paises y sus respectivas capitales, Algo como esto seria lo que retorna dicha api.

 


[
    {
        country: "Republica Dominicana",
        capital: "Santo Domingo"
    },
    {
        country: "Japon",
        capital: "Tokio"
    },
    {
        country: "Venezuela",
        capital: "Caracas"
    },
    {
        country: "Portugal",
        capital: "Lisboa"
    },
    {
        country: "Espana",
        capital: "Madrid"
    },
    {
        country: "Rusia",
        capital: "Moscow"
     },
     {
        country: "Colombia",
        capital: "Bogota"
     }
]

 
Una vez sabiendo la respuesta de nuestra api podemos construirle un cliente.

//
        //service api url
        String url = 'http://localhost.dev/country';

        // declarar un client http en este caso DefaultHttpClient
        HttpClient client = new DefaultHttpClient();

        //Como nuestro servicio es un metodo get usamos HTTPGet
        HttpGet request = new HttpGet(url);

        HttpResponse response;
        List entityResult;

        try {
            //Ejecutamos el request ya compuesto
            response = client.execute(request);

            StatusLine statusLine = response.getStatusLine();

            //El statusLine retorna el resultado del request a nivel de statusCode
            //AKA ( 200,404,500,401,403... )
            if (statusLine.getStatusCode() == HttpStatus.SC_OK) {

                //Si queremos el resultado del servicio (json) debemos de obtenerlo del payload del request
                //Que es obtenido como un InputStream el cual tendremos que convertir a String
                InputStream in = response.getEntity().getContent();

                
                BufferedReader buffered = new BufferedReader(new InputStreamReader(in));
                StringBuilder fullLines = new StringBuilder();

                String line;
                
                // 
                while ((line = buffered.readLine()) != null) {
                    fullLines.append(line);
                }

                String result = fullLines.toString()

                JSONArray objetos = new JSONArray(result);

                for(int i=0;i<objetos.length;i++){

                    JSONObject objeto = new JSONObject(objetos[i]);

                    /*

                        cada objecto sera compuesto por esto
                        {
                            country: "pais",
                            capital:"capital"
                        }

                    */

                }
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {

//

 
Para obtener cualquier valor de nuestro objeto json basta con solo decir, mas detalles en la pagina de documentacion de JSONObject

//
    objeto.getString
    objeto.getInt

    objecto.JSONObject

//

 
Este metodo (wrap) es el que usaremos para convertir el inputStream a un String y poder parsearlo a json.

//
	public static String inputStreamToString(InputStream in) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(in));

		StringBuilder sb = new StringBuilder();

		String line;

		while ((line = br.readLine()) != null) {
			sb.append(line);
		}

		return sb.toString();
	}

//

 
Eso seria todo si todos los metodos fueran de tipo GET pero en ocaciones tenemos metodo que reciben solo POST y parametros dentro del payload (json). El codigo seria bastante parecido, la diferencia principal es el uso de HTTPPost en vez de HTTPGet.

//
        String url = 'url_to_you_server_api.dev/postservice'

        HttpClient client = new DefaultHttpClient();

        HttpPost request = new HttpPost(url);

        JSONObject parametros = new JSONObject();

        parametros.put("usuario","usuario");
        parametros.put("clave","top_secret");

        StringEntity jsonEntity = new StringEntity( dataJson.toString() );

        HttpPost request = new HttpPost(url);

        //Agregar esto ya que algunos frameworks (nodejs frameworks) necesitan esto
        //para poder parsear los payloads automaticamente
        request.addHeader("Content-Type","application/json");

        //Se configura el payload a enviar al servicio
        request.setEntity(jsonEntity);

        //Ejecutamos el request ya compuesto
        response = client.execute(request);

        //De este punto en adelante es los mismo que una llamada GET al servicio.
        StatusLine statusLine = response.getStatusLine();
//

 
Como pueden notar realizar llamadas POST y GET con android es bastante facil y simple, Hoy dia ya hay varios frameowrks que abstraen esta funcionalidad de tener que relizar el request y parsear el json.

Android-async-http

robospice

Saludos.

Conectando Twitter con android (Twitterj4)

El uso de las redes sociales en aplicaciones moviles el dia de hoy es bastante utilizado, la mayoria de las paltaformas ofrecen sus api para ser consumidas por los developer y estos integrarlas a sus aplicaciones. Twitter no es la excepion ofreciendo todas las posibilidades de su pagina a una muy buena Api, desde simplemente ver un timelime hasta ver todo el historia de DMs.

Android y twitter

Para este tutorial estaremos utilizando la libreria Twitterj4, pueden pasar y darle un ojo cuando tengan tiempo.

Antes de comenzar a codear lo primero que necesitamos es crear una aplicacion de twitter para poder opterner los datos de “authenticacion” y todo lo demas.

Crear la aplicacion de twitter

twitter_img_01

llenar los campos obligatorios para poder crear la aplicacion.

Una vez creada tendran algo como esto.

twitter_img_02

Luego de crear nuestra aplicacion debemos de crear los token de aceso.

twitter_img_03

Una vez creado los datos de acceso tendremos los siguientes campos disponibles:

    -Access token
    -Access token secret
Una vez tengamos todos nuestros pareametros para la conexion, ya solo queda proseguir con el codigo.
1. Crear un projecto android con su editor predeterminado.
2.Agregar el jar de twitter4j (No olvidar agregarlo al export O simplemente copiar la libreria a la carpeta libs).
3.Modificar el archivo manifest y agregar estas lineas a la actividad que quieren que reciba el callback.
<intent-filter>
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />

    <data
            android:host="url-example"
            android:scheme="oauth" />
</intent-filter>

Agregar permisos de internet

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

La url es la que pondremos para que realice el callback con esa url de ejemplo funcionara, mas luego veran donde la editamos, pueden poner cualquier valor ahi.

Manos en el codigo.

Debemos de declarar varias constantes

    static String TWITTER_CONSUMER_KEY = "api key";
    static String TWITTER_CONSUMER_SECRET = "api secret";

    static final String TWITTER_CALLBACK_URL = "oauth://url-example";

Tenemos un metodo para realizar el login con twitter que es de esta forma.


    public void loginTwitter(){
        ConfigurationBuilder builder = new ConfigurationBuilder();
        builder.setOAuthConsumerKey(TWITTER_CONSUMER_KEY);
        builder.setOAuthConsumerSecret(TWITTER_CONSUMER_SECRET);
        Configuration configuration = builder.build();

        TwitterFactory factory = new TwitterFactory(configuration);
        Twitter twitter = factory.getInstance();

        try {
            requestToken = twitter.getOAuthRequestToken(TWITTER_CALLBACK_URL);

            startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(requestToken.getAuthenticationURL())));
        } catch (TwitterException e) {
            e.printStackTrace();
        }
    }

Nuestor metodo oncreate sera donde llamemos para hacer el login con twitter, tendriamos algo asi.

Creamos una variable estatica y privada para guardar el request token y tener la misma instancia. (No es la mejor forma pero es la mas rapida).

private static RequestToken requestToken;

 

public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        //Para los fines de este tutorial hare esto, pero no es recomendable hacer http request en el main thread.
        // Ya sera en otra ocacion donde explicare como hacer los request en segundo plano.
        // Simplemente usen un AsyncTask http://stackoverflow.com/questions/9671546/asynctask-android-example

        StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
        StrictMode.setThreadPolicy(policy);

        Uri data = getIntent().getData();

        if(data != null){
            String token = data.getQueryParameter("oauth_token");
            String oauthVerified = data.getQueryParameter("oauth_verifier"); //

            ConfigurationBuilder builder = new ConfigurationBuilder();
            builder.setOAuthConsumerKey(TWITTER_CONSUMER_KEY);
            builder.setOAuthConsumerSecret(TWITTER_CONSUMER_SECRET);

            Configuration conf = builder.build();

            TwitterFactory factory = new TwitterFactory(conf);

            Twitter twitter = factory.getInstance();

            RequestToken r = requestToken;

            if(twitter != null){
                try {
                    AccessToken accessToken = twitter.getOAuthAccessToken(r, oauthVerified);

                    this.setTitle("Twitter " + accessToken.getScreenName().toString());
                } catch (IllegalStateException e) {
                    e.printStackTrace();
                } catch (TwitterException e) {
                    e.printStackTrace();
                }
            }
        }else{
            loginTwitter();
        }
    }

Si todo sale bien tendrian algo como esto.
twitter_04

twitter_05

twitter_06

Referencias

Projecto completo

Twitter4j

Worker job usando Nodej.s

En alguno proyectos es necesario tener una tarea ejecutando cada cierto tiempo, la cual estaria haciendo desde un heardbeat hasta una consulta en una base de datos para consumir un web service en fin muchas cosas. En este tutorial estaré mostrando una alternativa al poderoso cron de Linux pero esta vez con nodejs.

El ejemplo consta de 2 archivos un archivo server.js que es nuestro servidor js y otro archivo llamado task.js que es nuestro cron.

Page1__Lucidchart

Una vez inciado el cron el envio de mensajes se realiza de la siguiente manera

 childProcess.send({values:[]}) 

Page2__Lucidchart

Server.js

var http = require('http');
var process = require('child_process');

var app = http.createServer(function(req,res){
	child.send({'key':'value'})

	res.end('hello');
});

console.log('server running');

// se realiza el fork del nuevo proceso
var child = process.fork('task.js');

// dispara el evento message hacia el fork
child.send({'key':'valor'})
console.log('proceso hijo iniciado');

app.listen(3000);

Task.js

var context = [];

(function(context){
    setInterval(function(){
        var value = context.pop()
        console.log('iteraciones ' + value);
    },1000);
})(context);

process.on('message',function(value){
    console.log('mensaje recibido');

    context.push(value);
});

Esta seria otra opcion para el task.
Task2.js

var context = [];

var process = function(){
    var value = context.pop()
    console.log('iteraciones ' + value);
}

process.on('message',function(value){
	console.log('mensaje recibido');
	context.push(value);
});

Mi recomendacion es que para algun proceso ligero/pesado y no quieras tener que incluir algun nuevo modulo de node.js o simplemente quieres manejarlo tu mismo lo intententes de esta manera.

Referencias

Child Process Nodejs

Source 

Sending objects

Fork process

Nota: Si requiren algo mas complejo con respecto a este tema recomiendo usar este modulo modulo.

Read more “Worker job usando Nodej.s”

Requests Una Libreria de Python para Python

Cuantos de nosotros no hemos estado trabajando con httplib2 y tenido que escribir código no Python (No pythonic way) mientras programamos algún proyecto el cual requiera cierta comunicación externa y nuestro código no queda como queremos, para ayudarnos ahi llega  Request.

Bueno para no cansarles mas el cuento he aqui algunos ejemplos de esta maravillosa libreria:

Simple GET request

 import json
 import requests
 resultado = requests.get('url.api') #awesome verdad?

Basic Auth request

## Y asi es un simple GET request con basic auth
    r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
    r.status_code
    200
    r.headers['content-type']
    'application/json; charset=utf8'
    r.encoding
##

Post request con un json payload:

##
    import json
    import requests
    rawPayload = {'nombre' : 'nombre'}
    resultado = requests.post('url.api',data=json.dumps(rawPayload))
##

Post request para enviar un archivo:

##
    import requests
    file = open('tu_archivo.file','r')
    result = requests.post('url.api',file={ 'file':file })
##

Referencias:

Presentacion

Documentacion oficial