2014 Archive - Antoine ARTAUD

nov

Opensuse Google Music

Posted by : admin | On : 11 novembre 2014

tested in version opensuse 13.2

download the rpm on google music

then execute the command line

sudo zypper in google-musicmanager-beta_current_x86_64.rpm source https://www.alionet.org/content.php?415-Skype-dropbox-google-earth-google-musicmanager-sur-openSUSE-12-3-RC1

Extract mp3 from flv

Tonight I tried to rip the audio track from a flv file. First I wanted to convert it into ogg but as the audio track is a mp3 stream itself I decided just to rip the mp3 data into a file (same quality as in the video file. A higher samplerate would only increase filesize).

UPDATE: Today the audiostream is often aac (not mp3 anymore). That means, you have to use mp4 instead of mp3 with ffmpeg … -f mp4 … .mp4).

One of those commands will do the job:
mplayer -dumpaudio in-video.flv -dumpfile out-audio.mp3
ffmpeg -i input.flv -f mp3 -vn -acodec copy output.mp3

To convert all files (*.flv to *.mp3) in the directory use one of the following commands:
for i in *.flv; do mplayer -dumpaudio -dumpfile « ${i/.flv} ».mp3 « $i »; done
for i in *.flv; do ffmpeg -i « $i » -f mp3 -vn -acodec copy « ${i/.flv} ».mp3; done

#ffmpeg: -f mp3 => force mp3 format, -vn => novideo, -acodec copy => stream-copy
# ${i/.flv} is cutting the filename $i from « .flv »

UPDATE: As the files are not always in the same format and my portable music player couldn’t play mp4 I decided to convert them to ogg.
ffmpeg -i input.flv/mp4 -vn -acodec vorbis output.ogg

This script will transform all flv files in your directory into mp3 files.

1. Create a new file e.g. with kate and name it flv2mp3.sh

#!/bin/bash
for i in *.flv
do
echo « $i »
# Alternative 1
# mplayer -dumpaudio -dumpfile « ${i/.flv} ».mp3 « $i »
#Alternative 2
ffmpeg -i « $i » -f mp3 -vn -acodec copy « ${i/.flv} ».mp3
done

2. Change the right of this file:
chmod +x flv2mp3.sh

3. Goto the directory and run the script

juil

.NET Backgroundworker

Posted by : admin | On : 1 juillet 2014

Category: Non classé

http://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker.aspx

http://msdn.microsoft.com/en-us/library/ms228966.aspx

juil

.NET WCF async

Posted by : admin | On : 1 juillet 2014

Category: .NET, Informatique

docs

http://jaliyaudagedara.blogspot.fr/2013/03/asynchronous-operations-in-wcf.html

http://www.codeproject.com/Articles/646239/NET-Asynchronous-Patterns

resources

https://onedrive.live.com/?cid=5f84eceeec6f3f8e&id=5F84ECEEEC6F3F8E!237&authkey=!ADqvp2nWpn6QtSw

sample code illustration

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AsyncWcfClient
{
    class Program
    {
        static wsService1.Service1Client client1 = new wsService1.Service1Client();
        static wsService2.Service2Client client2 = new wsService2.Service2Client();
        static wsService3.Service3Client client3 = new wsService3.Service3Client();

        static void Main(string[] args)
        {
            client1.GetDataCompleted += client_GetDataCompleted;
            client1.GetDataAsync("event-based asynchronous pattern");
            Console.WriteLine("Waiting for async operation...");

            //client1.BeginGetData("IAsyncResult asynchronous pattern (Client-Side)", new AsyncCallback(GetDataCallBack), null);
            //Console.WriteLine("Waiting for async operation...");

            //client2.BeginWorkerMethod("IAsyncResult asynchronous pattern (Server-Side)", new AsyncCallback(GetDataCallBack), null);
            //Console.WriteLine("Waiting for async operation...");

            //InvokeAsyncMethod("task-based asynchronous pattern");
            //Console.WriteLine("Waiting for async operation...");

            Console.ReadLine();
        }

        static void client_GetDataCompleted(object sender, wsService1.GetDataCompletedEventArgs e)
        {
            Console.WriteLine(e.Result.ToString());
        }

        ////IAsyncResult asynchronous pattern (Client-Side) callback
        //static void GetDataCallBack(IAsyncResult result)
        //{
        //    Console.WriteLine(client1.EndGetData(result).ToString());
        //}

        ////IAsyncResult asynchronous pattern (Server-Side) callback
        //static void GetDataCallBack(IAsyncResult result)
        //{
        //    Console.WriteLine(client2.EndWorkerMethod(result).ToString());
        //}

        //static async void InvokeAsyncMethod(string message)
        //{
        //    Console.WriteLine(await client3.MyWorkerMethodAsync(message));
        //}
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;

namespace AsyncWcfService
{
 // NOTE: You can use the "Rename" command on the "Refactor" menu to change the interface name "IService1" in both code and config file together.
 [ServiceContract]
 public interface IService1
 {
 //event-based asynchronous pattern
 [OperationContract]
 string GetData(string message);
 }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AsyncWcfService
{
 // NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "Service1" in code, svc and config file together.
 // NOTE: In order to launch WCF Test Client for testing this service, please select Service1.svc or Service1.svc.cs at the Solution Explorer and start debugging.
 public class Service1 : IService1
 {
 public string GetData(string message)
 {
 Thread.Sleep(5000);
 return message;
 }
 }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using System.Threading.Tasks;

namespace AsyncWcfService
{
 // NOTE: You can use the "Rename" command on the "Refactor" menu to change the interface name "IService2" in both code and config file together.
 [ServiceContract]
 public interface IService2
 {
 //IAsyncResult asynchronous pattern
 [OperationContractAttribute(AsyncPattern = true)]
 IAsyncResult BeginWorkerMethod(string message, AsyncCallback callback, object asyncState);

 string EndWorkerMethod(IAsyncResult result);
 }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AsyncWcfService
{
 // NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "Service2" in code, svc and config file together.
 // NOTE: In order to launch WCF Test Client for testing this service, please select Service2.svc or Service2.svc.cs at the Solution Explorer and start debugging.
 public class Service2 : IService2
 {
 public IAsyncResult BeginWorkerMethod(string message, AsyncCallback callback, object asyncState)
 {
 var task = Task<string>.Factory.StartNew((res) => MyMethod(asyncState,message), asyncState);
 return task.ContinueWith(res => callback(task));
 }

 public string EndWorkerMethod(IAsyncResult result)
 {
 return ((Task<string>)result).Result;
 }

 private string MyMethod(object asyncState,string message)
 {
 Thread.Sleep(5000);
 return message;
 }
 }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using System.Threading.Tasks;

namespace AsyncWcfService
{
 // NOTE: You can use the "Rename" command on the "Refactor" menu to change the interface name "IService3" in both code and config file together.
 [ServiceContract]
 public interface IService3
 {
 //task-based asynchronous pattern
 [OperationContract]
 Task<string> MyWorkerMethodAsync(string message);
 }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AsyncWcfService
{
 // NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "Service3" in code, svc and config file together.
 // NOTE: In order to launch WCF Test Client for testing this service, please select Service3.svc or Service3.svc.cs at the Solution Explorer and start debugging.
 public class Service3 : IService3
 {
 public async Task<string> MyWorkerMethodAsync(string message)
 {
 return await Task.Factory.StartNew(() => MyMethod(message));
 }

 private string MyMethod(string message)
 {
 Thread.Sleep(5000);
 return message;
 }
 }
}

juin

Wcf

Posted by : admin | On : 30 juin 2014

Category: Non classé

Async WCF Today and Tomorrow – Blog – Stephen Cleary

juin

.NET SQL command

Posted by : admin | On : 24 juin 2014

Category: .NET, Informatique, Non classé

Tags:.NET

http://www.kanazawa-net.ne.jp/~pmansato/parallel/parallel_taskfactory.htm

http://codereview.stackexchange.com/questions/44547/writing-highly-asynchronous-code

https://www.dropbox.com/s/f053j1pgw2qo9fz/AsynchronousProgramming.rar

http://chsakell.com/2014/01/11/asynchronous-programming-using-tasks/

http://slynetblog.blogspot.fr/2013/04/downloading-multiple-files-on-windows.html

Connection SQL Serveur

https://www.connectionstrings.com/sql-server-2008/

WCF Asynchronous

http://robbincremers.me/2011/12/31/wcf-asynchronous-client-proxy-and-asynchronous-service-operations/

http://stackoverflow.com/questions/8040002/how-to-make-a-wcf-rest-method-entirely-asynchronous-with-the-task-parallel-libra

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AsynchronousProgramming
{
    class Program
    {
        //const string connectionString = "Data source = localhost; Initial catalog = Chinook; Integrated security = SSPI;";
        const string connectionString = "Data Source=ARTAUDHOME\\SQLEXPRESS;Initial Catalog=Chinook;Integrated Security=True;Connect Timeout=15;Encrypt=False;TrustServerCertificate=False";
        static void Main(string[] args)
        {
            Thread.CurrentThread.Name = "MainThread";

            #region This will block the thread...
            DataSet dsArtists = GetArtistsAsync().Result;
            foreach (DataRow row in dsArtists.Tables["Artists"].Rows)
            {
               foreach (DataColumn col in dsArtists.Tables[0].Columns)
                {
                    Console.Write(row[col] + "\t");
                }
               Console.WriteLine();
            }
            #endregion

            #region This won't block the main thread
            //GetArtistsAsync().ContinueWith(task =>
            //{
            //    DataSet dsArtists = task.Result;
            //    foreach (DataRow row in dsArtists.Tables["Artists"].Rows)
            //    {
            //        foreach (DataColumn col in dsArtists.Tables[0].Columns)
            //        {
            //            Console.Write(row[col] + "\t");
            //        }
            //        Console.WriteLine();
            //    }
            //});
            #endregion

            #region This won't block the thread and catches exceptions
            //GetArtistsAsync().ContinueWith(task =>
            //{
            //    DataSet dsArtists = task.Result;
            //    foreach (DataRow row in dsArtists.Tables["Artists"].Rows)
            //    {
            //        foreach (DataColumn col in dsArtists.Tables[0].Columns)
            //        {
            //            Console.Write(row[col] + "\t");
            //        }
            //        Console.WriteLine();
            //    }
            //}, TaskContinuationOptions.NotOnFaulted);

            //GetArtistsAsync().ContinueWith(task =>
            //{
            //    Console.WriteLine(task.Exception.InnerException.Message);
            //}, TaskContinuationOptions.OnlyOnFaulted);

            #endregion

            #region Task Composition - Multithreading
            //var watch = Stopwatch.StartNew();

            //Task<DataSet> artistsTask = GetArtistsAsync();
            //Task<DataSet> albumsTask = GetAlbumsAsync();

            //Task.Factory.ContinueWhenAll(new[] { artistsTask, albumsTask }, (tasks) =>
            //{
            //    foreach (var task in tasks)
            //    {
            //        if (task.Status == TaskStatus.RanToCompletion)
            //        {
            //            DataSet ds = task.Result;
            //            if (ds.Tables[0].TableName == "Artists")
            //            {
            //                foreach (DataRow row in ds.Tables["Artists"].Rows)
            //                {
            //                    foreach (DataColumn col in ds.Tables[0].Columns)
            //                    {
            //                        Console.Write(row[col] + "\t");
            //                    }
            //                    Console.WriteLine();
            //                }
            //            }
            //            else if (ds.Tables[0].TableName == "Albums")
            //            {
            //                foreach (DataRow row in ds.Tables["Albums"].Rows)
            //                {
            //                    foreach (DataColumn col in ds.Tables[0].Columns)
            //                    {
            //                        Console.Write(row[col] + "\t");
            //                    }
            //                    Console.WriteLine();
            //                }
            //            }
            //        }
            //        else
            //        {
            //            Console.WriteLine("An error has occurred..");
            //            Console.WriteLine(task.Exception.InnerException.Message);
            //        }
            //        Console.WriteLine();
            //        Console.WriteLine("------------------------------------------------");
            //        Console.WriteLine();
            //    }

            //    watch.Stop();
            //    Console.WriteLine("Time elapsed: " + watch.ElapsedMilliseconds + " milliseconds");
            //});
            #endregion

            #region Asynchronous - No multithreading
            //GetCustomersAsync().ContinueWith((task) =>
            //{
            //    DataSet dsCustomers = task.Result;
            //    foreach (DataRow row in dsCustomers.Tables["Customers"].Rows)
            //    {
            //        foreach (DataColumn col in dsCustomers.Tables[0].Columns)
            //        {
            //            Console.Write(row[col] + "\t");
            //        }az
            //        Console.WriteLine();
            //    }
            //});

            #endregion

            Console.WriteLine();
            Console.WriteLine("Thread: " + Thread.CurrentThread.Name);
            Console.WriteLine("Press any key...");
            Console.ReadKey();
        }

        static Task<DataSet> GetArtistsAsync()
        {
            DataSet ds = new DataSet();
            return Task<DataSet>.Factory.StartNew(() =>
            {
                using (SqlConnection con = new SqlConnection(connectionString))
                {
                    string sqlSelect = @"WAITFOR DELAY '000:00:05'
                                        SELECT TOP 10 * FROM Artist";
                    SqlDataAdapter da = new SqlDataAdapter(sqlSelect, con);
                    da.Fill(ds);
                    ds.Tables[0].TableName = "Artists";
                }
                Console.WriteLine("Thread: " + Thread.CurrentThread.Name);
                return ds;
            });
        }

        static Task<DataSet> GetAlbumsAsync()
        {
            DataSet ds = new DataSet();
            return Task<DataSet>.Factory.StartNew(() =>
            {
                using (SqlConnection con = new SqlConnection(connectionString))
                {
                    string sqlSelect = @"WAITFOR DELAY '000:00:05'
                                        SELECT TOP 10 * FROM Album";
                    SqlDataAdapter da = new SqlDataAdapter(sqlSelect, con);
                    da.Fill(ds);
                    ds.Tables[0].TableName = "Albums";
                }
                Console.WriteLine("Thread: " + Thread.CurrentThread.Name);
                return ds;
            });
        }

        static Task<DataSet> GetCustomersAsync()
        {
            var tcs = new TaskCompletionSource<DataSet>();

            DataSet ds = new DataSet();

            using (SqlConnection con = new SqlConnection(connectionString))
            {
                string sqlSelect = @"WAITFOR DELAY '000:00:05'
                                        SELECT TOP 10 * FROM Customer";
                SqlDataAdapter da = new SqlDataAdapter(sqlSelect, con);
                da.Fill(ds);
                ds.Tables[0].TableName = "Customers";
            }
            Console.WriteLine("Thread in GetCustomersAsync: " + Thread.CurrentThread.Name);
            tcs.SetResult(ds);
            return tcs.Task;
        }
    }
}

juin

.NET4.0 TPL and PLINQ demo

Posted by : admin | On : 16 juin 2014

Category: .NET, Informatique

Tags:TPL;PLINQ;Multithreading

sample code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Collections.Concurrent;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            Action<Action> mesure = (body) =>
                {
                    var startTime = DateTime.Now;
                    body();
                    Console.WriteLine("{0} {1}", DateTime.Now - startTime, Thread.CurrentThread.ManagedThreadId);
                };

            Action calJob = () => { for (int i = 0; i < 350000000; i++); };
            Action ioJob = () => { Thread.Sleep(1000); };

            // TPL on top of thread
            /* mesure(() =>
                 {
                  var tasks = Enumerable.Range(1,10)
                              .Select(_ => Task.Factory.StartNew(() => mesure(ioJob)))
                              .ToArray();
                  Task.WaitAll(tasks); // Start 2 task in background
                 });*/

            //Parallel.For(1, 10, _ => { mesure(ioJob); });

            //PLINQ on top TPL
            //use of multiple core

            //Enumerable.Range(1,10).ToList().ForEach(_=>mesure(ioJob)); //no sort order
            //Enumerable.Range(1, 10).AsParallel().WithDegreeOfParallelism(10).ForAll(_ => mesure(ioJob));
            //ThreadPool.SetMinThreads(5, 5);
            // ParallelEnumerable.Range(1, 10).WithDegreeOfParallelism(10).ForAll(_ => mesure(calJob)); 

            //producer Xml reader => queue => consumer
            //var queue = new Queue<int>();

            var queue = new BlockingCollection<int>(100);// concurrent Queue
            var producers = Enumerable.Range(1, 10).Select(_ => Task.Factory.StartNew(() =>
            {
                Enumerable.Range(1, 100)
                    .ToList()
                    .ForEach(i =>
                {
                    queue.Add(i);
                    Thread.Sleep(100);
                });
            })).ToArray();

            var consumers = Enumerable.Range(1, 2).Select(_ => Task.Factory.StartNew(() =>
            {
                foreach(var item in queue.GetConsumingEnumerable()) //get next element and remove from the queue 
                {
                   Console.WriteLine(item);
                };
            })).ToArray();

            Task.WaitAll(producers); // run all producers 
            queue.CompleteAdding(); // when all producers have finished so that it will notify to the consumers when the queue is dequeue 

            Task.WaitAll(consumers);
            Console.ReadKey();
        }
    }
}

juin

.Net Task and parrallel treatement

Posted by : admin | On : 9 juin 2014

Category: .NET, Informatique

Tags:Parrallel programming, Task

http://www.symbolsource.org/Public/Metadata/NuGet/Project/SignalR.Client/0.3.3/Release/.NETFramework,Version%3Dv4.0/SignalR.Client/SignalR.Client/SignalR/TaskAsyncHelper.cs?ImageName=SignalR.Client

http://dotnetinside.com/en/type/SignalR.Hosting.AspNet/TaskAsyncHelper/0.5.1.10822

Linq grouping

http://weblogs.asp.net/dixin/understanding-linq-to-objects-3-query-methods

Nice Helper code


using System;

using System.Diagnostics;

using System.Linq;

using System.Threading.Tasks;

namespace SignalR {

 internal static class TaskAsyncHelper {

 private static Task MakeEmpty() {

 return FromResult<object>(null);

 }

 public static Task Empty {

 get {

 // we have to return a new one every time, other wise the task will be disposed

 return MakeEmpty();

 }

 }

 public static Task Catch(this Task task) {

 return task.ContinueWith(t => {

 if (t != null && t.IsFaulted) {

 var ex = t.Exception;

 Trace.TraceError("SignalR exception thrown by Task: {0}", ex);

 }

 return t;

 }).Unwrap();

 }

 public static Task<T> Catch<T>(this Task<T> task) {

 return task.ContinueWith(t => {

 if (t != null && t.IsFaulted) {

 var ex = t.Exception;

 Trace.TraceError("SignalR exception thrown by Task: {0}", ex);

 }

 return t;

 })

 .Unwrap();

 }

 public static Task Success(this Task task, Action<Task> successor) {

 return task.ContinueWith(_ => {

 if (task.IsCanceled || task.IsFaulted) {

 return task;

 }

 return Task.Factory.StartNew(() => successor(task));

 }).Unwrap();

 }

 public static Task Success<TResult>(this Task<TResult> task, Action<Task<TResult>> successor) {

 return task.ContinueWith(_ => {

 if (task.IsCanceled || task.IsFaulted) {

 return task;

 }

 return Task.Factory.StartNew(() => successor(task));

 }).Unwrap();

 }

 public static Task<TResult> Success<TResult>(this Task task, Func<Task, TResult> successor) {

 return task.ContinueWith(_ => {

 if (task.IsFaulted) {

 return FromError<TResult>(task.Exception);

 }

 if (task.IsCanceled) {

 return Cancelled<TResult>();

 }

 return Task.Factory.StartNew(() => successor(task));

 }).Unwrap();

 }

 public static Task<TResult> Success<T, TResult>(this Task<T> task, Func<Task<T>, TResult> successor) {

 return task.ContinueWith(_ => {

 if (task.IsFaulted) {

 return FromError<TResult>(task.Exception);

 }

 if (task.IsCanceled) {

 return Cancelled<TResult>();

 }

 return Task.Factory.StartNew(() => successor(task));

 }).Unwrap();

 }

 public static Task AllSucceeded(this Task[] tasks, Action continuation) {

 return AllSucceeded(tasks, _ => continuation());

 }

 public static Task AllSucceeded(this Task[] tasks, Action<Task[]> continuation) {

 return Task.Factory.ContinueWhenAll(tasks, _ => {

 var cancelledTask = tasks.FirstOrDefault(task => task.IsCanceled);

 if (cancelledTask != null)

 throw new TaskCanceledException();

 var allExceptions =

 tasks.Where(task => task.IsFaulted).SelectMany(task => task.Exception.InnerExceptions).ToList();

 if (allExceptions.Count > 0) {

 throw new AggregateException(allExceptions);

 }

 return Task.Factory.StartNew(() => continuation(tasks));

 }).Unwrap();

 }

 public static Task<T> AllSucceeded<T>(this Task[] tasks, Func<T> continuation) {

 return Task.Factory.ContinueWhenAll(tasks, _ => {

 var cancelledTask = tasks.FirstOrDefault(task => task.IsCanceled);

 if (cancelledTask != null)

 throw new TaskCanceledException();

 var allExceptions =

 tasks.Where(task => task.IsFaulted).SelectMany(task => task.Exception.InnerExceptions).ToList();

 if (allExceptions.Count > 0) {

 throw new AggregateException(allExceptions);

 }

 return Task.Factory.StartNew(continuation);

 }).Unwrap();

 }

 public static Task<T> FromResult<T>(T value) {

 var tcs = new TaskCompletionSource<T>();

 tcs.SetResult(value);

 return tcs.Task;

 }

 private static Task<T> FromError<T>(Exception e) {

 var tcs = new TaskCompletionSource<T>();

 tcs.SetException(e);

 return tcs.Task;

 }

 private static Task<T> Cancelled<T>() {

 var tcs = new TaskCompletionSource<T>();

 tcs.SetCanceled();

 return tcs.Task;

 }

 }

}

Resources

http://msdn.microsoft.com/en-us/library/ff963553.aspx

http://www.microsoft.com/en-us/download/confirmation.aspx?id=19222

Article

http://www.albahari.com/nutshell/cs4ch22.aspx

http://dotnetcodr.com/2014/03/18/continuation-tasks-in-net-tpl-many-tasks-continued-by-a-single-task/

Stackoverflow

http://stackoverflow.com/questions/15938254/task-results-into-a-single-list

mai

.Net Environnement

Posted by : admin | On : 30 mai 2014

Category: .NET, Informatique

Tags:.NET

Know your .NEt version

>cd %systemroot%\Microsoft.NET\Framework

>dir /A:D

Useful plugin for VS 2010

http://visualstudiogallery.msdn.microsoft.com/d0d33361-18e2-46c0-8ff2-4adea1e34fef

Nuget Package installer

http://docs.nuget.org/docs/start-here/using-the-package-manager-console

Func

http://stackoverflow.com/questions/13128271/task-run-and-func

mai

Tibco EMS Gems

Posted by : admin | On : 1 mai 2014

Category: Informatique, Tibco

Tibco GEMS

For download go to https://tibbr.tibcommunity.com/tibbr/#client-stream

Gems is a graphical user interface utility for TIBCO Enterprise Message Service (EMS). It can be used by JMS developers as a general purpose test debugging tool and by administrative support staff as a management and monitorig tool.

Gems provides the following main features:

Server Monitoring. Server state and main statistics are automtically updated, warning and error limits may be configured. Server generated events are also captured.
Server Management. Including, general server configuration, JMS destinations, JNDI factories, users/groups, permissions, bridges, routes etc.
JMS support. Messages may be sent/received, queues may be browsed and message contents inspected. Selectors and filters may be specified.
JMS Message Monitoring. Messages may be monitored (snooped) as they pass trough the server. Request and reply messages can be correlated to provide service response times.
JMS Message Management. Eg; purging messages, copy messages from a queue to another queue on a different server.
Charting. Server statistics may be charted in real time, data may be saved to CSV files for export to other tools such as Excel.
Logging. Server statistics may be logged automatically when warning or error limits are breached.
Security. SSL connectivity, view only mode.
Customisable display and look and feel.
Support for Managing and Monitoring TIBCO SubStation
Support for Monitoring TIBCO EMS Appliance.
Support for Migrating to TIBCO EMS Appliance.

Requires:

TIBCO EMS 5.0 or later
JRE 1.6 or later

fév

Asyntask and Multithreading Android

Posted by : admin | On : 20 février 2014

Category: Android, Informatique

Tags:multithreading

Good article

http://www.androiddesignpatterns.com/2013/04/retaining-objects-across-config-changes.html

http://www.vogella.com/tutorials/AndroidBackgroundProcessing/article.html#concurrency_asynchtask_parallel

Java generalities

Grand collisionneur de hadrons (LHC)

Jar Executable

Samba

JMS Java

Opensuse Google Music

Extract mp3 from flv

.NET Backgroundworker

.NET WCF async

Wcf

.NET SQL command

WCF Asynchronous

.NET4.0 TPL and PLINQ demo

.Net Task and parrallel treatement

.Net Environnement

Tibco EMS Gems

Asyntask and Multithreading Android

Pages

Categories

Archives

Blogrolls