Esempio n. 1
0
        Task StartAsync(string adapterId, AdapterMetadata adapterMetadata, string correlationId, IDictionary <string, string> startupValues = null)
        {
            if (processStarted)
            {
                throw new Exception("Already started.");
            }

            if (startupValues == null)
            {
                startupValues = new Dictionary <string, string>();
            }
            startupValues.Add(Constants.CorrelationIdName, correlationId);

            adapterLogger = loggerFactory.CreateLogger($"{adaptersNamingPrefix}.{adapterId}".ToLower());


            var startupValuesBase64     = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(startupValues)));
            var serverlessOptionsBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(serverlessOptions)));
            var adapterValuesBase64     = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(adapterMetadata.AdapterValues)));

            process = new Process
            {
                StartInfo = new ProcessStartInfo("dotnet")
                {
                    Arguments        = $"\"{adapterMetadata.LocalPath}\" {serverlessOptionsBase64} {startupValuesBase64} {adapterValuesBase64}",
                    WorkingDirectory = Path.GetDirectoryName(adapterMetadata.LocalPath),
                    UseShellExecute  = false,

                    RedirectStandardInput  = true,
                    RedirectStandardOutput = true,
                    RedirectStandardError  = true,

                    StandardInputEncoding  = Encoding.UTF8,
                    StandardOutputEncoding = Encoding.UTF8,
                    StandardErrorEncoding  = Encoding.UTF8,
                }
            };

            process.OutputDataReceived += OutputDataReceived;
            process.ErrorDataReceived  += ErrorDataReceived;

            if (!process.Start())
            {
                throw new Exception("Process reused!");
            }

            processStarted = true;

            process.BeginOutputReadLine();
            process.BeginErrorReadLine();

            return(Task.CompletedTask);
        }
Esempio n. 2
0
        async public Task StartAsync(string adapterId, string correlationId, string adapterPath, IDictionary <string, string> startupValues = null)
        {
            if (!File.Exists(adapterPath))
            {
                throw new FileNotFoundException(adapterPath);
            }

            var fakeMetadata = new AdapterMetadata
            {
                LocalPath = adapterPath
            };

            await StartAsync(adapterId, fakeMetadata, correlationId, startupValues);
        }
Esempio n. 3
0
        async Task <AdapterMetadata> GetAdapterMetadata(string adapterId)
        {
            if (memoryCache.TryGetValue($"{adaptersNamingPrefix}.{adapterId}", out AdapterMetadata adapterMetadata))
            {
                return(adapterMetadata);
            }

            //using var cloudFilesService = new CloudFilesService(serverlessOptions.CloudFilesOptions);

            var metaData = await cloudFilesService.GetMetadataAsync($"{serverlessOptions.AdapterRemotePath}/{adapterId}".ToLower());

            adapterMetadata = new AdapterMetadata
            {
                EntryAssembly = metaData["EntryAssembly"],
                Hash          = metaData["Hash"],
                AdapterValues = new Dictionary <string, string>(metaData)
            };

            adapterMetadata.LocalPath = Path.GetFullPath($"{serverlessOptions.AdapterLocalPath}/{adapterMetadata.Hash}/{adapterMetadata.EntryAssembly}");


            return(memoryCache.Set($"{adaptersNamingPrefix}.{adapterId}", adapterMetadata, TimeSpan.FromMinutes(serverlessOptions.AdapterMetadataCacheDuration)));
        }