Exemplo n.º 1
0
        public StartPage()
        {
            // Prevent duplicate instances
            if (instance != null)
                throw new DuplicateInstanceException(typeof(StartPage));

            InitializeComponent();

            // Set StartPage only dockable to document area
            DockAreas = DockAreas.Document;

            // Set up browser for interfacing
            startPageBrowser.ObjectForScripting = startPageInterface;

            // Load Resource Data
            var compiler = new FormatCompiler();
            template = compiler.Compile(Resources.StartPageTemplate);
            LayoutCSS = Resources.StartPageLayout;
            themeDark = Resources.StartPageDark;
            themeLight = Resources.StartPageLight;

            ColorThemeCSS = themeDark;

            // Load Start Page
            LoadPage();

            AttachEventHandlers(); // This one messes with the browser, so do it last.
        }
Exemplo n.º 2
0
        public Renderer(Template template, IImageService imageService)
        {
            _template = template;
            _imageService = imageService;
            _compiler = new FormatCompiler();
            _compiler.RegisterTag(new ImgUrlTagDefinition(imageService), true);

            _generator = _compiler.Compile(_template.HTML);
        }
Exemplo n.º 3
0
        public Template(string templateFile)
        {
            string template = File.ReadAllText(templateFile);

            FormatCompiler mustacheCompiler = new FormatCompiler();
            mustacheCompiler.RemoveNewLines = false;

            mustacheGenerator = mustacheCompiler.Compile(template);
        }
        private void CrearMDL(ClientInputMessage e, Int64 subid, Double[] valores, SimulacionParameters parametros,
            Generator generatorMDL)
        {
            try
            {
                MDLParametros mdlParametros = new MDLParametros();
                mdlParametros.iteraciones = parametros.init.iterations;
                mdlParametros.timeStep = parametros.init.timeStep;
                mdlParametros.box = new BoxParametros();
                mdlParametros.box.nombre = parametros.geometria.box.nombre;
                mdlParametros.box.aspectRatio = parametros.geometria.box.aspectRatio;
                LinkedList<String> cornerList = new LinkedList<String>();
                foreach (var corner in parametros.geometria.box.corners)
                {
                    String cornerString = "[" + String.Join(",", corner) + "]";
                    cornerList.AddLast(cornerString);
                }
                mdlParametros.box.corners = String.Join(" , ", cornerList);
                mdlParametros.moleculas = new DefMoleculas();
                mdlParametros.moleculas.defineMoleculas = new LinkedList<MoleculasParametros>();
                mdlParametros.moleculas.nameList = parametros.moleculas.nameList;

                foreach (var molecula in parametros.moleculas.defineMoleculas)
                {
                    MoleculasParametros mol = new MoleculasParametros();
                    mol.nombre = molecula.nombre;
                    mol.cantidad = molecula.cantidad;
                    mol.diffusion2D = molecula.difusion2D;
                    mol.diffusion3D = molecula.difusion3D;
                    mdlParametros.moleculas.defineMoleculas.AddLast(mol);
                }

                mdlParametros.reacciones = new LinkedList<ReacParametros>();
                var numReaccion = 0;
                foreach (var reaccion in parametros.reacciones)
                {
                    ReacParametros reac = new ReacParametros();
                    reac.reaccion = reaccion.reaccion;
                    reac.rate = valores[numReaccion];
                    reac.nombre = reaccion.nombre;
                    mdlParametros.reacciones.AddLast(reac);
                    numReaccion++;
                }
                mdlParametros.hayReacciones = mdlParametros.reacciones.Count > 0;

                string fernetMode = parametros.fernet.mode;

                Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");//("en-US");
                string result = generatorMDL.Render(mdlParametros);

                // Se obtiene una referencia al blob (que no existia previamente)
                CloudBlockBlob blockBlob = container.GetBlockBlobReference("Scene.main.mdl-" + fernetMode + "-" + e.idUsuario + "." + subid);

                // Se guarda el mdl en blob
                blockBlob.UploadText(result);

                //enviar mensaje al JobCreation Role
                var role = RoleEnvironment.Roles["JobCreation"];
                Trace.WriteLine("Number of JobCreation Instances found: " + role.Instances.Count, "Information");

                RoleInstance instance = role.Instances.FirstOrDefault<RoleInstance>();

                /*
             * ALGORITMO LOAD BALANCER
             * instance - La instancia que se seleccionara como resultado final del algoritmo LB
             * idles, lows, normals listas para categorizar los nodos segun utilizacion de CPU y memoria mediante el algoritmo de LB
             * Los nodos categorizados como high no se almacenan porque seran automaticamente descartados por el algoritmo
             * Se utiliza la estructura EntradaLoadBalancer para almacenar informacion relevante para el algoritmo
             * L, H - constantes para determinar el umbral de carga de utilizacion de CPU (definidas arriba)
             * */
                DateTime StartDate = DateTime.Now;

                List<LoadBalancerEntry> nodos = new List<LoadBalancerEntry>();
                List<LoadBalancerEntry> idles = new List<LoadBalancerEntry>();
                List<LoadBalancerEntry> lows = new List<LoadBalancerEntry>();
                List<LoadBalancerEntry> normals = new List<LoadBalancerEntry>();
                Double cpuUsageInstance = 0;

                //Recoleccion de metricas de utilizacion de CPU y memoria para cada instancia
                if (role.Instances.Count > 0)
                {
                    double sumCpu = 0;
                    LoadBalancerCommons lbo = new LoadBalancerCommons();
                    foreach (var i in role.Instances)
                    {
                        double cpu = LoadBalancerCommons.obtenerMetricas(i.Id, "JobCreation", true);
                        double memory = LoadBalancerCommons.obtenerMetricas(i.Id, "JobCreation", false);

                        LoadBalancerEntry entrada = new LoadBalancerEntry();
                        entrada.cpuUsage = cpu;
                        entrada.memoryUsage = memory;
                        entrada.rol = i;
                        nodos.Add(entrada);

                        sumCpu += cpu;
                    }

                    double avCPUClusterUsage = sumCpu / (role.Instances.Count);
                    double lUmbral = LoadBalancerCommons.L * avCPUClusterUsage;
                    double hUmbral = LoadBalancerCommons.H * avCPUClusterUsage;

                    /* Agrupamos los nodos en categorias dependiendo de la intensidad de uso de CPU y Memoria
                    *  Si tienen alto uso de Cpu y memoria simultaneamente son automaticamente descartados por el algoritmo
                    */
                    foreach (LoadBalancerEntry entry in nodos)
                    {
                        if (entry.cpuUsage <= LoadBalancerCommons.IDLE)
                        {
                            idles.Add(entry);
                        }
                        else if (entry.cpuUsage <= lUmbral && (!(entry.memoryUsage >= LoadBalancerCommons.H_LOADED)))
                        {
                            lows.Add(entry);
                        }
                        else if ((!(entry.memoryUsage >= LoadBalancerCommons.H_LOADED)) && (!(entry.cpuUsage >= hUmbral)))
                        {
                            normals.Add(entry);
                        }
                    }

                    /* ETAPA DE CLASIFICACION
                    *  Como los servidores cuentan con Balance de Carga, siempre debe haber al menos uno que no este en la
                    *  categoria High, es decir que siempre habra elementos en alguna de las siguientes 3 categorias
                    */
                    if (idles.Count > 0)
                    {
                        instance = idles.First().rol;
                        cpuUsageInstance = idles.First().cpuUsage;
                    }
                    else if (lows.Count > 0)
                    {
                        instance = lows.First().rol;
                        cpuUsageInstance = lows.First().cpuUsage;
                    }
                    else if (normals.Count > 0)
                    {
                        instance = normals.First().rol;
                        cpuUsageInstance = normals.First().cpuUsage;
                    }
                }
                //END ALGORITMO LOAD BALANCER
                DateTime EndDate = DateTime.Now;
                Int32 resta = (EndDate - StartDate).Milliseconds;

                CloudBlockBlob loadBalancerMetrics = container.GetBlockBlobReference("loadBalancerMetrics");

                if (!loadBalancerMetrics.Exists())
                {
                    loadBalancerMetrics.UploadText(DateTime.Now.ToShortTimeString() + ": Load balancer demoró " + resta + " ms y eligió " + instance.Id + " con " + cpuUsageInstance + "% CPU");
                }
                else {
                    String aux = loadBalancerMetrics.DownloadText();
                    aux = aux + "\n" + DateTime.Now.ToShortDateString() + ": Load balancer demoró " + resta + " ms y eligió " + instance.Id + " con " + cpuUsageInstance + "% CPU";

                    loadBalancerMetrics.UploadText(aux);
                }

                RoleInstanceEndpoint jobSubmissionServiceHostEndPoint = instance.InstanceEndpoints["JobSubmissionServiceEndPoint"];

                NetTcpBinding binding = new NetTcpBinding(SecurityMode.None, false);

                EndpointAddress myEndpoint = new EndpointAddress(
                    String.Format("net.tcp://{0}/JobSubmissionService", jobSubmissionServiceHostEndPoint.IPEndpoint)
                    );

                try
                {
                    ChannelFactory<InterroleCommons.IReceiveJobSubmission> myChanFac = new ChannelFactory<InterroleCommons.IReceiveJobSubmission>(binding, myEndpoint);
                    InterroleCommons.IReceiveJobSubmission myClient = myChanFac.CreateChannel();
                    myClient.ReceiveJobSubmitionMessage(new InterroleCommons.JobSubmissionMessage() { idUsuario = e.idUsuario, nomEntrada = "Scene.main.mdl-" + fernetMode + "-" + e.idUsuario + "." + subid, subIdUsuario = Convert.ToString(subid) });
                }
                catch (Exception ex)
                {
                    Trace.WriteLine("An error occured trying send Job Submission to the instances: " + ex.Message, "Warning");
                }

            }
            catch (Exception ex)
            {
                Trace.TraceError(ex.Message);
                throw;
            }
        }