OliviaAddInPro/Services/LanzaSrv/LanzaOlvServ.cs

using OliviaAddInPro.Model;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace OliviaAddInPro.Services.LanzaSrv
{
    /*
     * ejecuta antiguo
     * */
    public class LanzaOlvServ
    {
        //*************************************************************************************
        //Enums
        public enum ModosEjec
        {
            Secto,
            Planif,
            SoloPlanif,
        }
        //*************************************************************************************
        //Variables         
        /**
         * Cadena general de escritura de parámetros de configuración para envío por socket
         */
        public string str_cfg;
        /**
         * Cadena general de escritura de parámetros para envío por socket
         */
        public string str;

        public string NombreTratamiento;
        

        //*************************************************************************************
        public LanzaOlvServ()
        {
            str = "";
        }
         ~LanzaOlvServ() // destructor (finalizers)
        {
            // cleanup statements...
        }

        public Respuesta<bool> ejec(string NTratamiento)
        {
            NombreTratamiento = NTratamiento;
            add_cfg_comun();
            
            //lanza ventana marchando que lanza proceso en bucle para actualizar barra progreso
            //OliviaGlob.progr_eje = new ProgresoEjec();

            //lanza proceso OliviaTask
            var res = lanza();
            if (!res.Value)
            {
                res.Error.Add("Error al arrancar OliviaTask (programa de procesado de datos): No ha arrancado correctamente la instancia OliviaTask");
                res.Value = true;
                return res;
            }

            //OliviaGlob.progr_eje.start(str_cfg);

            return res;
        }

        /**
         * Añade al str de cfg los parametros de configuración comunes a limpieza y recogida
         */
        private void add_cfg_comun()
        {
            str_cfg = str_cfg +
                //campos de la red navegable
                GeneralDef.EjecGeoParamSep + GeneralDef.GTC_onew + GeneralDef.EjecGeoParamIgual + ComunDef.CamposNW.cons_onew + " " +
                GeneralDef.EjecGeoParamSep + GeneralDef.GTC_kph + GeneralDef.EjecGeoParamIgual + ComunDef.CamposNW.cons_kph + " " +
                GeneralDef.EjecGeoParamSep + GeneralDef.GTC_fow + GeneralDef.EjecGeoParamIgual + ComunDef.CamposNW.cons_fow + " " +
                GeneralDef.EjecGeoParamSep + GeneralDef.GTC_name + GeneralDef.EjecGeoParamIgual + ComunDef.CamposNW.cons_name + " " +
                GeneralDef.EjecGeoParamSep + GeneralDef.GTA_TF + GeneralDef.EjecGeoParamIgual + ComunDef.AtributosNW.atr_TF + " " +
                GeneralDef.EjecGeoParamSep + GeneralDef.GTA_FT + GeneralDef.EjecGeoParamIgual + ComunDef.AtributosNW.atr_FT + " " +
                GeneralDef.EjecGeoParamSep + GeneralDef.GTA_N + GeneralDef.EjecGeoParamIgual + ComunDef.AtributosNW.atr_N + " " +
                GeneralDef.EjecGeoParamSep + GeneralDef.GTA_pedes + GeneralDef.EjecGeoParamIgual + ComunDef.AtributosNW.atr_pedes + " " +
                //nombre del tratamiento
                GeneralDef.EjecGeoParamSep + GeneralDef.GG_strtto + GeneralDef.EjecGeoParamIgual + NombreTratamiento + " " +
                //paths de archivos
                GeneralDef.EjecGeoParamSep + GeneralDef.GG_pd + GeneralDef.EjecGeoParamIgual + OliviaGlob.Paths.PathData + " " +
                GeneralDef.EjecGeoParamSep + GeneralDef.GG_pn + GeneralDef.EjecGeoParamIgual + OliviaGlob.Paths.PathNW + " ";
        }

        /**
         * Arranca el proceso OliviaTask con los parámetros correspondientes
         */
        private Respuesta<bool> lanza()
        {
            Process[] pg;
            string args;
            ProcessStartInfo pfi;
            var res = new Respuesta<bool>();

            try
            {
                //van ParamN parámetros, sin incluir, si se añaden, incrementar ParamN
                args = GeneralDef.EjecGeoParamSep + GeneralDef.GG_tipo + GeneralDef.EjecGeoParamIgual + ((int)OliviaGlob.TipoEjec).ToString() + " " +
                        GeneralDef.EjecGeoParamSep + GeneralDef.GG_ip + GeneralDef.EjecGeoParamIgual + OliviaGlob.Conexion.Ip + " " +
                        GeneralDef.EjecGeoParamSep + GeneralDef.GG_port + GeneralDef.EjecGeoParamIgual + OliviaGlob.Conexion.Puerto + " " +
                        GeneralDef.EjecGeoParamSep + GeneralDef.GG_tout + GeneralDef.EjecGeoParamIgual + OliviaGlob.Conexion.TiempoOutSocket + " " +
                        GeneralDef.EjecGeoParamSep + GeneralDef.GG_pt + GeneralDef.EjecGeoParamIgual + OliviaGlob.Paths.PathTemp + " " +
                        GeneralDef.EjecGeoParamSep + GeneralDef.GG_pcfg + GeneralDef.EjecGeoParamIgual + OliviaGlob.Paths.PathCfg + " ";

                pfi = new ProcessStartInfo(OliviaGlob.Paths.PathExeOlivia, args);
                System.Diagnostics.Process.Start(pfi);

                //comprueba que haya arrancado OliviaTask
                //le da 2 seg de margen para que arranque
                pg = Is_process(GeneralDef.NombOlvTasks, 2, true);
                if (pg == null)
                {
                    res.Error.Add(string.Format("No está OliviaTask, args= {0}", args));
                    res.Value = false;
                    return res;
                }
            }
            catch (Exception e)
            {
                res.Error.Add(string.Format("Error al lanzar proceso, args= {0}", e.Message));
                res.Value = false;
                return res;
            }
            res.Value = true;
            return res;
        }


        /**
         * Itera para comprobar que ha arrancado bien un proceso, o ver si está arrancado
         * int t_max : seg espera
         * bool espera_start : si true, se quiere esperar t_max a que arranque, 
         * si false, se quiere esperar a que se cierre
         * Devuelve el proceso si está, para cancelarlo, y null si no está
         */
        public Process[] Is_process(string nombproc, int t_max, bool espera_start)
        {
            bool esta_geo = !espera_start;
            int veces = 0;
            int veces_max;
            int milis_sleep = 50;

            if (t_max <= 0)
                t_max = 1;
            veces_max = t_max * 1000 / milis_sleep;

            Process[] pg = new Process[0];

            //si ya está arrancado y se quiere esperar a que se cierre, esta_geo=true y espera_start=false;
            //por lo que se cumple !espera_start && esta_geo
            //tiene que esperar si esta_geo==true
            //cuando se quiere esperar a que arranque, esta_geo=false y espera_start=true
            //por lo que se cumple (espera_start && !esta_geo)
            //en este caso, tiene que esperar si esta_geo==False
            while (((espera_start && !esta_geo) || (!espera_start && esta_geo)) && (veces < veces_max))
            {
                try
                {
                    pg = Process.GetProcessesByName(nombproc);
                    if (pg.Length == 0)
                        esta_geo = false;
                    else
                        esta_geo = true;
                }
                catch (InvalidOperationException)
                {
                    esta_geo = false;
                }

                if (((espera_start && !esta_geo) || (!espera_start && esta_geo)))
                {
                    veces++;
                    Thread.Sleep(milis_sleep);
                }
            }

            if (esta_geo)
                return pg;
            else
                return null;
        }
    }
}