예제 #1
0
        /// <summary>
        /// If we do not have enterprise enabled, copy the book and remove all enterprise level features.
        /// </summary>
        internal static bool PrepareBookForUpload(ref Book.Book book, BookServer bookServer, string tempFolderPath, IProgress progress)
        {
            if (book.CollectionSettings.HaveEnterpriseFeatures)
            {
                return(false);
            }

            // We need to be sure that any in-memory changes have been written to disk
            // before we start copying/loading the new book to/from disk
            book.Save();

            Directory.CreateDirectory(tempFolderPath);
            BookStorage.CopyDirectory(book.FolderPath, tempFolderPath);
            var bookInfo   = new BookInfo(tempFolderPath, true);
            var copiedBook = bookServer.GetBookFromBookInfo(bookInfo);

            copiedBook.BringBookUpToDate(new NullProgress(), true);
            var pages = new List <XmlElement>();

            foreach (XmlElement page in copiedBook.GetPageElements())
            {
                pages.Add(page);
            }
            ISet <string> warningMessages = new HashSet <string>();

            PublishHelper.RemoveEnterpriseFeaturesIfNeeded(copiedBook, pages, warningMessages);
            PublishHelper.SendBatchedWarningMessagesToProgress(warningMessages, progress);
            copiedBook.Save();
            copiedBook.Storage.UpdateSupportFiles();
            book = copiedBook;
            return(true);
        }
예제 #2
0
        private bool ProcessOneMsg(byte[] msgBytes)
        {
            var head = SiMsgHelper.GetSiMsgHead(msgBytes);

            switch (head.u16MsgType)
            {
            case SiMacroDef.O_SILMTENB_GETFILEINFO_RES:
                PublishHelper.PublishMsg("topic", msgBytes);                            //TODO topic协商
                break;

            case SiMacroDef.O_SILMTENB_GETFILEATTRIB_RES:
                break;

            case SiMacroDef.O_SILMTENB_SETRDWRATTRIB_RES:
                break;

            case SiMacroDef.O_SILMTENB_DELFILE_RES:
                break;

            case SiMacroDef.O_SILMTENB_GETCAPACITY_RES:
                break;

            default:
                //TODO 不知道是什么啊,老铁
                break;
            }
            return(true);
        }
        /// <summary>Called when the item is saving.</summary>
        protected void OnItemSaving(object sender, EventArgs args)
        {
            Assert.ArgumentNotNull(sender, "sender");
            Assert.ArgumentNotNull((object)args, "args");

            // Do not run rules when installting Sitecore packages
            if (Sitecore.Context.Job?.Name == "Install")
            {
                return;
            }

            // Do not run rules when publishing
            if (!Settings.Rules.ItemEventHandlers.RunDuringPublishing && PublishHelper.IsPublishing())
            {
                return;
            }

            Item obj = Event.ExtractParameter(args, 0) as Item;

            if (obj == null)
            {
                return;
            }

            this.RunItemSavingRules(obj);
        }
예제 #4
0
        /// <summary>
        /// 发送开关按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            IList <TraceSetTreeModel> selectList     = GetCheckedItems();
            List <string>             lstrSelectName = new List <string>();

            string strTest = string.Empty;

            byte[] arrySwitch = new byte[256];
            for (int i = 0; i < 256; i++)
            {
                arrySwitch[i] = 0;
            }


            for (int i = 0; i < selectList.Count; i++)
            {
                //lstrSelectName.Add(selectList[i].Name);
                int nID = GetIDByName(selectList[i].Name);

                arrySwitch[nID] = 1;

                strTest += nID.ToString() + ": " + arrySwitch[nID].ToString() + "\n";
            }

            PublishHelper.PublishMsg("/AtpBack/TraceConfig/StartTrace", arrySwitch);
            ParseMessageWindow Pw = new ParseMessageWindow();

            Pw.Show();
        }
예제 #5
0
        private void ParseUdpData(UdpDataInfo data)
        {
            //TODO 需要确定是否要去掉其他的数据

            //处理完成后,通过接口发送给CDL
            PublishHelper.PublishMsg("/AtpBack/CDLParse/MsgParse", data.UdpDataBytes);
        }
예제 #6
0
        /// <summary>
        /// 发送数据,为登录和注销使用。
        /// 登录时,SerssionService需要创建连接;注销时,则删除连接
        /// </summary>
        /// <param name="dataBytes">要发送板卡的数据</param>
        /// <param name="isLogon">是否登陆操作</param>
        /// <returns></returns>
        public int SendPackets(byte[] dataBytes, bool isLogon)
        {
            if (null == dataBytes)
            {
                throw new ArgumentNullException("dataBytes is null");
            }

            SessionData sessionData = new SessionData(dataBytes.Length)
            {
                target =
                {
                    raddr = _netElementConfig.TargetIp,
                    rport = CommonPort.AtpLinkPort,
                    laddr = _netElementConfig.TraceIp
                },
                data = dataBytes
            };

            string sendBytes = JsonHelper.SerializeObjectToString(sessionData);

            //创建和断开连接的topic比较特殊
            string act   = (isLogon ? "Create" : "Delete");
            string topic = string.Format($"/SessionService/{act}/UDP");

            PublishHelper.PublishMsg(topic, sendBytes);
            return(sendBytes.Length);
        }
예제 #7
0
        public async Task <DeployStatus> PerformServerSideBuild(Site functionApp, Func <Task <Stream> > zipFileFactory, Func <HttpClient, Task <DeployStatus> > deploymentStatusPollTask)
        {
            using (var handler = new ProgressMessageHandler(new HttpClientHandler()))
                using (var client = GetRemoteZipClient(new Uri($"https://{functionApp.ScmUri}"), handler))
                    using (var request = new HttpRequestMessage(HttpMethod.Post, new Uri(
                                                                    $"api/zipdeploy?isAsync=true&author={Environment.MachineName}", UriKind.Relative)))
                    {
                        ColoredConsole.WriteLine("Creating archive for current directory...");

                        request.Headers.IfMatch.Add(EntityTagHeaderValue.Any);

                        (var content, var length) = CreateStreamContentZip(await zipFileFactory());
                        request.Content           = content;
                        HttpResponseMessage response = await PublishHelper.InvokeLongRunningRequest(client, handler, request, length, "Uploading");

                        await PublishHelper.CheckResponseStatusAsync(response, "Uploading archive...");

                        // Streaming deployment status for Linux Server Side Build
                        DeployStatus status = await deploymentStatusPollTask(client);

                        if (status == DeployStatus.Success)
                        {
                            ColoredConsole.WriteLine(Green("Remote build succeeded!"));
                        }
                        else if (status == DeployStatus.Failed)
                        {
                            throw new CliException("Remote build failed!");
                        }
                        else if (status == DeployStatus.Unknown)
                        {
                            ColoredConsole.WriteLine(Yellow($"Failed to retrieve remote build status, please visit https://{functionApp.ScmUri}/api/deployments"));
                        }
                        return(status);
                    }
        }
예제 #8
0
        public override async Task RunAsync()
        {
            // Get function app
            var functionApp = await AzureHelper.GetFunctionApp(FunctionAppName, AccessToken, ManagementURL);

            // Get the GitIgnoreParser from the functionApp root
            var functionAppRoot = ScriptHostHelpers.GetFunctionAppRootDirectory(Environment.CurrentDirectory);
            var ignoreParser    = PublishHelper.GetIgnoreParser(functionAppRoot);

            // Get the WorkerRuntime
            var workerRuntime = WorkerRuntimeLanguageHelper.GetCurrentWorkerRuntimeLanguage(_secretsManager);

            // Check for any additional conditions or app settings that need to change
            // before starting any of the publish activity.
            var additionalAppSettings = await ValidateFunctionAppPublish(functionApp, workerRuntime);

            if (workerRuntime == WorkerRuntime.dotnet && !Csx && !NoBuild)
            {
                if (DotnetHelpers.CanDotnetBuild())
                {
                    var outputPath = Path.Combine("bin", "publish");
                    await DotnetHelpers.BuildDotnetProject(outputPath, DotnetCliParameters);

                    Environment.CurrentDirectory = Path.Combine(Environment.CurrentDirectory, outputPath);
                }
                else if (StaticSettings.IsDebug)
                {
                    ColoredConsole.WriteLine("Could not find a valid .csproj file. Skipping the build.");
                }
            }

            if (workerRuntime != WorkerRuntime.dotnet || Csx)
            {
                // Restore all valid extensions
                var installExtensionAction = new InstallExtensionAction(_secretsManager, false);
                await installExtensionAction.RunAsync();
            }

            if (ListIncludedFiles)
            {
                InternalListIncludedFiles(ignoreParser);
            }
            else if (ListIgnoredFiles)
            {
                InternalListIgnoredFiles(ignoreParser);
            }
            else
            {
                if (PublishLocalSettingsOnly)
                {
                    await PublishLocalAppSettings(functionApp, additionalAppSettings);
                }
                else
                {
                    await PublishFunctionApp(functionApp, ignoreParser, additionalAppSettings);
                }
            }
        }
    public void OnAcceptButton()
    {
        PublishHelper _publishHelper = FindObjectOfType <PublishHelper>();

        _publishHelper.SerializeUser();

        mainPanel.SetActive(true);
        confirmCapPanel.SetActive(false);
    }
예제 #10
0
        public int SendPackets(byte[] dataBytes)
        {
            if (null == dataBytes)
            {
                throw new ArgumentNullException("dataBytes is null");
            }

            PublishHelper.PublishMsg($"udp-send://{_netElementConfig.TargetIp}:{CommonPort.AtpLinkPort}", dataBytes);
            return(dataBytes.Length);
        }
예제 #11
0
        /// <summary>
        /// 发送报文。直接调用了PublishHelper
        /// </summary>
        /// <param name="dataBytes">要发送的数据流</param>
        /// <param name="topic">该数据流对应的topic</param>
        /// <returns>发送的字节数</returns>
        public int SendPackets(byte[] dataBytes, string topic)
        {
            if (null == dataBytes)
            {
                throw new ArgumentNullException("dataBytes is null");
            }

            PublishHelper.PublishMsg(topic, dataBytes);
            return(dataBytes.Length);
        }
예제 #12
0
        /// <summary>
        /// 主界面进行隐藏时调用,清空所有信息,并发送停止消息
        /// </summary>
        public void ClearAll()
        {
            UE_List.Clear();
            ENB_List.Clear();
            GNB_List.Clear();
            lbUE.Items.Clear();
            lbeNB.Items.Clear();
            lbgNB.Items.Clear();

            PublishHelper.PublishMsg("StopTraceHlSignal", "");
        }
예제 #13
0
        private void Updater()
        {
            DateTime initialTruncationTime    = DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(LogTruncateInterval));
            DateTime initialDiagnosticLogTime = DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(DiagnosticLogIntervalInMinutes));

            while (true)
            {
                int eventId = WaitHandle.WaitAny(_waitHandleArray, Interval);
                if (eventId == 0)
                {
                    //If exitevent is signalled, the process is exiting.
                    break;
                }

                #region Update Operations

                PublishHelper.LogVerboseInformation("UpdaterThread: Found {0} completed operations to update", _completedOperations.Count);
                if (_completedOperations.Count > 0)
                {
                    lock (_completedOperations)
                    {
                        while (_completedOperations.Count > 0)
                        {
                            var operation = _completedOperations.Dequeue();
                            PublishHelper.UpdatePublishOperation(operation.OperationId, operation.SiteName, operation.Status);
                        }
                    }
                }

                #endregion

                #region Remove Stale Operations

                if ((DateTime.UtcNow - initialTruncationTime).TotalMinutes > LogTruncateInterval)
                {
                    initialTruncationTime = DateTime.UtcNow;
                    PublishHelper.LogVerboseInformation("LogTruncaterThread: Removing Stale Operations");
                    PublishHelper.RemoveStalePublishOperations();
                }

                #endregion

                #region Log Diagnostic Data

                if ((DateTime.UtcNow - initialDiagnosticLogTime).TotalMinutes > DiagnosticLogIntervalInMinutes)
                {
                    initialDiagnosticLogTime = DateTime.UtcNow;
                    PublishHelper.LogOperationCount();
                }

                #endregion
            }
        }
예제 #14
0
        internal PublishManager(string serviceName)
        {
            _exitEvent       = new AutoResetEvent(false);
            _continueEvent   = new AutoResetEvent(false);
            _waitHandleArray = new WaitHandle[] { _exitEvent, _continueEvent };

            _pendingPublishOperations = new Queue <Operation>();
            _completedOperations      = new Queue <Operation>();
            _pendingDeleteOperations  = new Queue <Operation>();

            _operationsInProgress = new HashSet <string>();
            PublishHelper.LogVerboseInformation("PublishManager initialized");
            ServicePointManager.ServerCertificateValidationCallback += CertificateHelper.CertificateValidationCallback;
        }
        public void ReportTechnologyPollingAssignmentIndication(
            ITechnologyPolling technologyPolling,
            int[] netObjectsInstanceIDs,
            bool enabledStateChangedTo)
        {
            if (technologyPolling == null)
            {
                throw new ArgumentNullException(nameof(technologyPolling));
            }
            if (netObjectsInstanceIDs == null)
            {
                throw new ArgumentNullException(nameof(netObjectsInstanceIDs));
            }
            if (netObjectsInstanceIDs.Length == 0)
            {
                return;
            }
            ITechnology technology      = TechnologyManager.Instance.TechnologyFactory.GetTechnology(technologyPolling.get_TechnologyID());
            string      netObjectPrefix = NetObjectTypesDAL.GetNetObjectPrefix(this.swisFactory, technology.get_TargetEntity());
            string      entityName      = NetObjectTypesDAL.GetEntityName(this.swisFactory, technology.get_TargetEntity());
            Dictionary <int, string> netObjectsCaptions = NetObjectTypesDAL.GetNetObjectsCaptions(this.swisFactory, technology.get_TargetEntity(), netObjectsInstanceIDs);

            foreach (int objectsInstanceId in netObjectsInstanceIDs)
            {
                PropertyBag propertyBag1 = new PropertyBag();
                ((Dictionary <string, object>)propertyBag1).Add("InstanceType", (object)"Orion.TechnologyPollingAssignments");
                ((Dictionary <string, object>)propertyBag1).Add("InstanceID", (object)objectsInstanceId.ToString());
                ((Dictionary <string, object>)propertyBag1).Add("TechnologyPollingID", (object)technologyPolling.get_TechnologyPollingID());
                ((Dictionary <string, object>)propertyBag1).Add("Enabled", (object)enabledStateChangedTo);
                ((Dictionary <string, object>)propertyBag1).Add("TargetEntity", (object)technology.get_TargetEntity());
                ((Dictionary <string, object>)propertyBag1).Add("TechPollingDispName", (object)technologyPolling.get_DisplayName());
                ((Dictionary <string, object>)propertyBag1).Add("TechnologyDispName", (object)technology.get_DisplayName());
                PropertyBag propertyBag2 = propertyBag1;
                string      str;
                if (netObjectsCaptions.TryGetValue(objectsInstanceId, out str))
                {
                    ((Dictionary <string, object>)propertyBag2).Add("NetObjectCaption", (object)str);
                }
                if (netObjectPrefix != null)
                {
                    ((Dictionary <string, object>)propertyBag2).Add("NetObjectPrefix", (object)netObjectPrefix);
                    ((Dictionary <string, object>)propertyBag2).Add((string)KnownKeys.NetObject, (object)string.Format("{0}:{1}", (object)netObjectPrefix, (object)objectsInstanceId));
                }
                if (entityName != null)
                {
                    ((Dictionary <string, object>)propertyBag2).Add("NetObjectName", (object)entityName);
                }
                this.publishManager.Publish(PublishHelper.ConvertIndication((IIndication) new TechnologyPollingAssignmentIndication((IndicationType)2, propertyBag2)));
            }
        }
예제 #16
0
        public async Task <DeployStatus> PerformServerSideBuild(Site functionApp, Func <Task <Stream> > zipFileFactory, Func <HttpClient, Task <DeployStatus> > deploymentStatusPollTask, bool attachRestrictedToken = true)
        {
            if (string.IsNullOrEmpty(functionApp.ScmUri))
            {
                throw new CliException("Remote build is a new feature added to function apps. " +
                                       $"Your function app {functionApp.SiteName} does not support remote build as it was created before August 1st, 2019.");
            }

            using (var handler = new ProgressMessageHandler(new HttpClientHandler()))
                using (var client = GetRemoteZipClient(new Uri($"https://{functionApp.ScmUri}"), handler))
                    using (var request = new HttpRequestMessage(HttpMethod.Post, new Uri(
                                                                    $"api/zipdeploy?isAsync=true&author={Environment.MachineName}", UriKind.Relative)))
                    {
                        ColoredConsole.WriteLine("Creating archive for current directory...");

                        request.Headers.IfMatch.Add(EntityTagHeaderValue.Any);

                        (var content, var length) = CreateStreamContentZip(await zipFileFactory());
                        request.Content           = content;

                        if (attachRestrictedToken)
                        {
                            // Attach x-ms-site-restricted-token for Linux Consumption remote build
                            string restrictedToken = await KuduLiteDeploymentHelpers.GetRestrictedToken(functionApp, AccessToken, ManagementURL);

                            request.Headers.Add("x-ms-site-restricted-token", restrictedToken);
                        }
                        HttpResponseMessage response = await PublishHelper.InvokeLongRunningRequest(client, handler, request, length, "Uploading");

                        await PublishHelper.CheckResponseStatusAsync(response, "Uploading archive...");

                        // Streaming deployment status for Linux Server Side Build
                        DeployStatus status = await deploymentStatusPollTask(client);

                        if (status == DeployStatus.Success)
                        {
                            ColoredConsole.WriteLine(Green("Remote build succeeded!"));
                        }
                        else if (status == DeployStatus.Failed)
                        {
                            throw new CliException("Remote build failed!");
                        }
                        return(status);
                    }
        }
예제 #17
0
        private void DealSendTraceSwitchRsp(string ip, byte[] dataBytes)
        {
            if (string.IsNullOrWhiteSpace(ip) ||
                string.IsNullOrEmpty(ip))
            {
                throw new ArgumentNullException();
            }

            if (!HasLinkWithSameIp(ip))
            {
                return;
            }

            MsgGtsa2GtsmTraceCtrlRsp rsp = (MsgGtsa2GtsmTraceCtrlRsp)SerializeHelper.BytesToStruct(dataBytes, typeof(MsgGtsa2GtsmTraceCtrlRsp));

            byte[] rspBytes = new byte[] { rsp.u8Complete };
            PublishHelper.PublishMsg("/AtpFront/TraceConfig/TraceActRsp", rspBytes);
        }
예제 #18
0
        /// <summary>
        /// 发送消息跟踪控制开关
        /// </summary>
        /// <param name="switchs">前台已经处理好的开关</param>
        /// <returns></returns>
        public bool SendTraceSwitch(byte[] switchs)
        {
            //创建IP连接
            SessionData sessionData = new SessionData(10)
            {
                target =
                {
                    raddr = _netElementConfig.TargetIp,
                    rport = CommonPort.AtpLinkPort,
                    laddr = _netElementConfig.TraceIp
                }
            };
            string sendBytes = JsonHelper.SerializeObjectToString(sessionData);

            PublishHelper.PublishMsg("/SessionService/Create/IP", sendBytes);

            return(SendTSwitchs(switchs, _netElementConfig));
        }
예제 #19
0
        public override async Task RunAsync()
        {
            // Get function app
            var functionApp = await AzureHelper.GetFunctionApp(FunctionAppName, AccessToken);

            // Get the GitIgnoreParser from the functionApp root
            var functionAppRoot = ScriptHostHelpers.GetFunctionAppRootDirectory(Environment.CurrentDirectory);
            var ignoreParser    = PublishHelper.GetIgnoreParser(functionAppRoot);

            // Get the WorkerRuntime
            var workerRuntime = WorkerRuntimeLanguageHelper.GetCurrentWorkerRuntimeLanguage(_secretsManager);

            // Check for any additional conditions or app settings that need to change
            // before starting any of the publish activity.
            var additionalAppSettings = ValidateFunctionAppPublish(functionApp, workerRuntime);

            if (workerRuntime == WorkerRuntime.dotnet && !Csx && !NoBuild)
            {
                const string outputPath = "bin/publish";
                await DotnetHelpers.BuildDotnetProject(outputPath, DotnetCliParameters);

                Environment.CurrentDirectory = Path.Combine(Environment.CurrentDirectory, outputPath);
            }

            if (ListIncludedFiles)
            {
                InternalListIncludedFiles(ignoreParser);
            }
            else if (ListIgnoredFiles)
            {
                InternalListIgnoredFiles(ignoreParser);
            }
            else
            {
                if (PublishLocalSettingsOnly)
                {
                    await PublishLocalAppSettings(functionApp, additionalAppSettings);
                }
                else
                {
                    await PublishFunctionApp(functionApp, ignoreParser, additionalAppSettings);
                }
            }
        }
예제 #20
0
 //接收数据线程函数
 private void RecvFromBoard(object obj)
 {
     while (true)
     {
         try
         {
             var revBytes = _udpClient.Receive(ref _ipTargetEp);
             var header   = GetHeaderFromBytes.GetHeader(revBytes);
             PublishHelper.PublishMsg($"udp-recv://{_prefix}", revBytes);
         }
         catch (SocketException e)
         {
             if (SocketError.Interrupted == e.SocketErrorCode)
             {
                 break;
             }
         }
     }
 }
예제 #21
0
        private void Bind_PublishContentStart()
        {
            if (modelTask.IsPublishContent == 1)
            {
                PublishHelper publich = new PublishHelper();
                publich.ModelTask = modelTask;
                publich.PublishCompalteDelegate = GatherWorkDelegate;

                MessageOut("正在开始发布数据!");
                publich.PublishCompalteDelegate = PublishCompalteDelegate;
                ThreadPool.QueueUserWorkItem(new WaitCallback(publich.Start));
            }
            else
            {
                GatherComplateDelegate(modelTask);
                MessageOut("发布数据没有开启!不需要发布数据!");
                this.Stop();
            }
        }
예제 #22
0
        /// <summary>
        /// Given a book, typically one in a temporary folder made just for exporting (or testing),
        /// and given the set of fonts found while creating that book and removing hidden elements,
        /// find the files needed for those fonts.
        /// Copy the font file for the normal style of that font family from the system font folder,
        /// if permitted; or post a warning in progress if we can't embed it.
        /// Create an extra css file (fonts.css) which tells the book to find the font files for those font families
        /// in the local folder, and insert a link to it into the book.
        /// </summary>
        /// <param name="fontFileFinder">use new FontFinder() for real, or a stub in testing</param>
        public static void EmbedFonts(Book.Book book, IWebSocketProgress progress, HashSet <string> fontsWanted, IFontFinder fontFileFinder)
        {
            const string defaultFont = "Andika New Basic";             // already in BR, don't need to embed or make rule.

            fontsWanted.Remove(defaultFont);
            PublishHelper.CheckFontsForEmbedding(progress, fontsWanted, fontFileFinder, out List <string> filesToEmbed, out HashSet <string> badFonts);
            foreach (var file in filesToEmbed)
            {
                // Enhance: do we need to worry about problem characters in font file names?
                var dest = Path.Combine(book.FolderPath, Path.GetFileName(file));
                RobustFile.Copy(file, dest);
            }
            // Create the fonts.css file, which tells the browser where to find the fonts for those families.
            var sb = new StringBuilder();

            foreach (var font in fontsWanted)
            {
                if (badFonts.Contains(font))
                {
                    continue;
                }
                var group = fontFileFinder.GetGroupForFont(font);
                if (group != null)
                {
                    EpubMaker.AddFontFace(sb, font, "normal", "normal", group.Normal);
                }
                // We don't need (or want) a rule to use Andika instead.
                // The reader typically WILL use Andika, because we have a rule making it the default font
                // for the whole body of the document, and BloomReader always has it available.
                // However, it's possible that although we aren't allowed to embed the desired font,
                // the device actually has it installed. In that case, we want to use it.
            }
            RobustFile.WriteAllText(Path.Combine(book.FolderPath, "fonts.css"), sb.ToString());
            // Tell the document to use the new stylesheet.
            book.OurHtmlDom.AddStyleSheet("fonts.css");
            // Repair defaultLangStyles.css and other places in the output book if needed.
            if (badFonts.Any())
            {
                PublishHelper.FixCssReferencesForBadFonts(book.FolderPath, defaultFont, badFonts);
                PublishHelper.FixXmlDomReferencesForBadFonts(book.OurHtmlDom.RawDom, defaultFont, badFonts);
            }
        }
예제 #23
0
        /// <summary>
        /// Handler for Linux Consumption publish event
        /// </summary>
        /// <param name="functionAppRoot">Function App project path in local machine</param>
        /// <param name="functionApp">Function App in Azure</param>
        /// <param name="fileNameNoExtension">Name of the file to be uploaded</param>
        /// <returns>ShouldSyncTrigger value</returns>
        private async Task <bool> HandleLinuxConsumptionPublish(string functionAppRoot, Site functionApp, string fileNameNoExtension)
        {
            // Choose if the content need to use remote build
            BuildOption     buildOption  = PublishHelper.UpdateLinuxConsumptionBuildOption(PublishBuildOption);
            GitIgnoreParser ignoreParser = PublishHelper.GetIgnoreParser(functionAppRoot);

            // We update the buildOption, so we need to update the zipFileStream factory as well
            Func <Task <Stream> > zipFileStreamTask = () => ZipHelper.GetAppZipFile(functionAppRoot, BuildNativeDeps, buildOption, NoBuild, ignoreParser, AdditionalPackages, ignoreDotNetCheck: true);

            // Consumption Linux, try squashfs as a package format.
            if (GlobalCoreToolsSettings.CurrentWorkerRuntimeOrNone == WorkerRuntime.python && !NoBuild && (BuildNativeDeps || buildOption == BuildOption.Remote))
            {
                if (BuildNativeDeps)
                {
                    await PublishRunFromPackage(functionApp, await PythonHelpers.ZipToSquashfsStream(await zipFileStreamTask()), $"{fileNameNoExtension}.squashfs");

                    return(true);
                }

                // Remote build don't need sync trigger, container will be deallocated once the build is finished
                if (buildOption == BuildOption.Remote)
                {
                    await RemoveFunctionAppAppSetting(functionApp,
                                                      "WEBSITE_RUN_FROM_PACKAGE",
                                                      "WEBSITE_CONTENTAZUREFILECONNECTIONSTRING",
                                                      "WEBSITE_CONTENTSHARE");
                    Task <DeployStatus> pollConsumptionBuild(HttpClient client) => KuduLiteDeploymentHelpers.WaitForConsumptionServerSideBuild(client, functionApp, AccessToken, ManagementURL);

                    var deployStatus = await PerformServerSideBuild(functionApp, zipFileStreamTask, pollConsumptionBuild);

                    return(deployStatus == DeployStatus.Success);
                }
            }
            else
            {
                await PublishRunFromPackage(functionApp, await zipFileStreamTask(), $"{fileNameNoExtension}.zip");

                return(true);
            }
            return(true);
        }
예제 #24
0
        public async Task PublishZipDeploy(Site functionApp, Func <Task <Stream> > zipFileFactory)
        {
            await RetryHelper.Retry(async() =>
            {
                using (var handler = new ProgressMessageHandler(new HttpClientHandler()))
                    using (var client = GetRemoteZipClient(new Uri($"https://{functionApp.ScmUri}"), handler))
                        using (var request = new HttpRequestMessage(HttpMethod.Post, new Uri("api/zipdeploy", UriKind.Relative)))
                        {
                            request.Headers.IfMatch.Add(EntityTagHeaderValue.Any);

                            ColoredConsole.WriteLine("Creating archive for current directory...");

                            (var content, var length) = CreateStreamContentZip(await zipFileFactory());
                            request.Content           = content;

                            HttpResponseMessage response = await PublishHelper.InvokeLongRunningRequest(client, handler, request, length, "Uploading");
                            await PublishHelper.CheckResponseStatusAsync(response, "uploading archive");
                            ColoredConsole.WriteLine("Upload completed successfully.");
                        }
            }, 2);
        }
예제 #25
0
        public async Task <DeployStatus> PerformServerSideBuild(Site functionApp, Func <Task <Stream> > zipFileFactory, Func <HttpClient, Task <DeployStatus> > deploymentStatusPollTask)
        {
            if (string.IsNullOrEmpty(functionApp.ScmUri))
            {
                throw new CliException($"Remote build is a new feature added to function apps.{Environment.NewLine}" +
                                       $"Your function app {functionApp.SiteName} does not support remote build as it was created before August 1st, 2019.{Environment.NewLine}" +
                                       $"Please use '--build local', '--build-native-deps' or manually enable remote build.{Environment.NewLine}" +
                                       $"For more information, please visit https://aka.ms/remotebuild");
            }

            using (var handler = new ProgressMessageHandler(new HttpClientHandler()))
                using (var client = GetRemoteZipClient(new Uri($"https://{functionApp.ScmUri}"), handler))
                    using (var request = new HttpRequestMessage(HttpMethod.Post, new Uri(
                                                                    $"api/zipdeploy?isAsync=true&author={Environment.MachineName}", UriKind.Relative)))
                    {
                        ColoredConsole.WriteLine("Creating archive for current directory...");

                        request.Headers.IfMatch.Add(EntityTagHeaderValue.Any);

                        (var content, var length) = CreateStreamContentZip(await zipFileFactory());
                        request.Content           = content;
                        HttpResponseMessage response = await PublishHelper.InvokeLongRunningRequest(client, handler, request, length, "Uploading");

                        await PublishHelper.CheckResponseStatusAsync(response, "Uploading archive...");

                        // Streaming deployment status for Linux Server Side Build
                        DeployStatus status = await deploymentStatusPollTask(client);

                        if (status == DeployStatus.Success)
                        {
                            ColoredConsole.WriteLine(Green("Remote build succeeded!"));
                        }
                        else if (status == DeployStatus.Failed)
                        {
                            throw new CliException("Remote build failed!");
                        }
                        return(status);
                    }
        }
예제 #26
0
        public void SendHlMessageToUI(ScriptMessage inputMessage)
        {
            //作一个随机延时20ms~50ms
            TimeDelay();
            //添加时间戳
            inputMessage.time = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss.fff");
            string originUI = inputMessage.UI;

            //区分三类消息,对应于界面呈现使用
            if (-1 != originUI.IndexOf("UE"))
            {
                inputMessage.NO = UENo++;
                inputMessage.UI = "UE";
                string msg = JsonConvert.SerializeObject(inputMessage);
                PublishHelper.PublishMsg("HlSignalMsg", msg);
                //记录日志
                logMsg.WriteLog(LogOfType.UE_MSGLOG, msg);
            }
            if (-1 != originUI.IndexOf("eNB"))
            {
                inputMessage.NO = eNBNo++;
                inputMessage.UI = "eNB";
                string msg = JsonConvert.SerializeObject(inputMessage);
                PublishHelper.PublishMsg("HlSignalMsg", msg);
                //记录日志
                logMsg.WriteLog(LogOfType.eNB_MSGLOG, msg);
            }
            if (-1 != originUI.IndexOf("gNB"))
            {
                inputMessage.NO = gNBNo++;
                inputMessage.UI = "gNB";
                string msg = JsonConvert.SerializeObject(inputMessage);
                PublishHelper.PublishMsg("HlSignalMsg", msg);
                //记录日志
                logMsg.WriteLog(LogOfType.gNB_MSGLOG, msg);
            }
        }
예제 #27
0
        public async Task <DeployStatus> PerformServerSideBuild(Site functionApp, Func <Task <Stream> > zipFileFactory)
        {
            using (var handler = new ProgressMessageHandler(new HttpClientHandler()))
                using (var client = GetRemoteZipClient(new Uri($"https://{functionApp.ScmUri}"), handler))
                    using (var request = new HttpRequestMessage(HttpMethod.Post, new Uri(
                                                                    $"api/zipdeploy?isAsync=true&author={Environment.MachineName}", UriKind.Relative)))
                    {
                        ColoredConsole.WriteLine("Creating archive for current directory...");

                        request.Headers.IfMatch.Add(EntityTagHeaderValue.Any);

                        // Attach x-ms-site-restricted-token for Linux Consumption remote build
                        string restrictedToken = await KuduLiteDeploymentHelpers.GetRestrictedToken(functionApp, AccessToken, ManagementURL);

                        (var content, var length) = CreateStreamContentZip(await zipFileFactory());
                        request.Content           = content;
                        request.Headers.Add("x-ms-site-restricted-token", restrictedToken);

                        HttpResponseMessage response = await PublishHelper.InvokeLongRunningRequest(client, handler, request, length, "Uploading");

                        await PublishHelper.CheckResponseStatusAsync(response, "uploading archive");

                        // Streaming deployment status for Linux Dynamic Server Side Build
                        DeployStatus status = await KuduLiteDeploymentHelpers.WaitForServerSideBuild(client, functionApp, AccessToken, ManagementURL);

                        if (status == DeployStatus.Success)
                        {
                            ColoredConsole.WriteLine(Green("Server side build succeeded!"));
                        }
                        else if (status == DeployStatus.Failed)
                        {
                            ColoredConsole.WriteLine(Red("Server side build failed!"));
                        }
                        return(status);
                    }
        }
예제 #28
0
        private async Task <IDictionary <string, string> > ValidateFunctionAppPublish(Site functionApp, WorkerRuntime workerRuntime)
        {
            var result = new Dictionary <string, string>();

            // Check version
            if (!functionApp.IsLinux)
            {
                if (functionApp.AzureAppSettings.TryGetValue(Constants.FunctionsExtensionVersion, out string version))
                {
                    // v2 can be either "~2", "beta", or an exact match like "2.0.11961-alpha"
                    if (!version.Equals("~2") &&
                        !version.StartsWith("2.0") &&
                        !version.Equals("beta", StringComparison.OrdinalIgnoreCase))
                    {
                        if (Force)
                        {
                            result.Add(Constants.FunctionsExtensionVersion, "~2");
                        }
                        else
                        {
                            throw new CliException("You're trying to publish to a non-v2 function app from v2 tooling.\n" +
                                                   "You can pass --force to force update the app to v2, or switch to v1 or v3 tooling for publishing");
                        }
                    }
                }
            }

            if (functionApp.AzureAppSettings.TryGetValue(Constants.FunctionsWorkerRuntime, out string workerRuntimeStr))
            {
                var resolution = $"You can pass --force to update your Azure app with '{workerRuntime}' as a '{Constants.FunctionsWorkerRuntime}'";
                try
                {
                    var azureWorkerRuntime = WorkerRuntimeLanguageHelper.NormalizeWorkerRuntime(workerRuntimeStr);
                    if (azureWorkerRuntime != workerRuntime)
                    {
                        if (Force)
                        {
                            ColoredConsole.WriteLine(WarningColor($"Setting '{Constants.FunctionsWorkerRuntime}' to '{workerRuntime}' because --force was passed"));
                            result[Constants.FunctionsWorkerRuntime] = workerRuntime.ToString();
                        }
                        else
                        {
                            throw new CliException($"Your Azure Function App has '{Constants.FunctionsWorkerRuntime}' set to '{azureWorkerRuntime}' while your local project is set to '{workerRuntime}'.\n"
                                                   + resolution);
                        }
                    }
                }
                catch (ArgumentException) when(Force)
                {
                    result[Constants.FunctionsWorkerRuntime] = workerRuntime.ToString();
                }
                catch (ArgumentException) when(!Force)
                {
                    throw new CliException($"Your app has an unknown {Constants.FunctionsWorkerRuntime} defined '{workerRuntimeStr}'. Only {WorkerRuntimeLanguageHelper.AvailableWorkersRuntimeString} are supported.\n" +
                                           resolution);
                }
            }

            if (!functionApp.AzureAppSettings.ContainsKey("AzureWebJobsStorage") && functionApp.IsDynamic)
            {
                throw new CliException($"'{FunctionAppName}' app is missing AzureWebJobsStorage app setting. That setting is required for publishing consumption linux apps.");
            }

            if (functionApp.IsLinux && !functionApp.IsDynamic && !string.IsNullOrEmpty(functionApp.LinuxFxVersion))
            {
                // If linuxFxVersion does not match any of our images
                if (PublishHelper.IsLinuxFxVersionUsingCustomImage(functionApp.LinuxFxVersion))
                {
                    ColoredConsole.WriteLine($"Your functionapp is using a custom image {functionApp.LinuxFxVersion}.\nAssuming that the image contains the correct framework.\n");
                }
                // If there the functionapp is our image but does not match the worker runtime image, we either fail or force update
                else if (!PublishHelper.IsLinuxFxVersionRuntimeMatched(functionApp.LinuxFxVersion, workerRuntime))
                {
                    if (Force)
                    {
                        var updatedSettings = new Dictionary <string, string>
                        {
                            [Constants.LinuxFxVersion] = $"DOCKER|{Constants.WorkerRuntimeImages.GetValueOrDefault(workerRuntime).FirstOrDefault()}"
                        };
                        var settingsResult = await AzureHelper.UpdateWebSettings(functionApp, updatedSettings, AccessToken, ManagementURL);

                        if (!settingsResult.IsSuccessful)
                        {
                            ColoredConsole.Error
                            .WriteLine(ErrorColor("Error updating linux image version:"))
                            .WriteLine(ErrorColor(settingsResult.ErrorResult));
                        }
                    }
                    else
                    {
                        throw new CliException($"Your Linux dedicated app has the container image version (LinuxFxVersion) set to {functionApp.LinuxFxVersion} which is not expected for the worker runtime {workerRuntime}. " +
                                               $"To force publish use --force. This will update your app to the expected image for worker runtime {workerRuntime}\n");
                    }
                }
            }

            return(result);
        }
예제 #29
0
 /// <summary>
 /// gtsa发送过来的跟踪消息,直接publish
 /// </summary>
 /// <param name="msgData"></param>
 private void DealTraceMsg(byte[] msgData)
 {
     PublishHelper.PublishMsg("/GtsMsgParseService/GtsaSend", msgData);
 }
 public void IsLinuxFxVersionRuntimeMatchedTest(string linuxFxVersion, WorkerRuntime runtime, bool expected)
 {
     Assert.Equal(expected, PublishHelper.IsLinuxFxVersionRuntimeMatched(linuxFxVersion, runtime));
 }