精华内容
下载资源
问答
  • 远程升级,前提是服务器上要有对应的apk文件
  • 原理是WFormSrc 在起动时检测本地的版本与服务器上的版本进行比较,如果不同则起动Update.exe进行升级,同时更新本地的版本设置 Update.exe不要放在服务器上 每次升级时只需要更改服务器上的配置文件的版本,同是把...
  • 嵌入式终端软件远程自动升级软件

    热门讨论 2007-11-11 13:02:35
    <br>本软件: 本软件可以做为大多终端软件的一个独立进程,从而使终端软件具备远程自动升级功能。 文件例表: Ftp.h、Ftp.c 完成一个带权限认证的基于RFC959标准的FTP文件上传下载功能的客户端 ...
  • 织梦CMS大家都知道,参考了其自动更新的步骤,整理了一下大体思路:1: 更新服务器指定目录需要一个每次升级的版本记录文件例如格式: 更新日期,字符集,版本号,更新标题,更新文件的压缩包(压缩包内是更新需要的文件)...

    织梦CMS大家都知道,参考了其自动更新的步骤,整理了一下大体思路:

    1: 更新服务器指定目录需要一个每次升级的版本记录文件

    例如格式: 更新日期,字符集,版本号,更新标题,更新文件的压缩包(压缩包内是更新需要的文件)

    20140415,V5.7.41,20140415常规更新补丁,http://upgrade.diyi01.com/upgrade/upgrade-20140415.zip

    2: 获取客户网站的最近更新日期,该日期可存于数据库或者文件)

    3: 读取远程更新服务器更新文件信息,然后比对客户网站需要更新那些压缩包

    4: 读取远程压缩包的配置文件(该文件记录压缩包内的文件列表),并根据\配置文件判断是否客户网站是否有写入权限,

    如:

    下载的文件临时存放在文件夹(../data/20140415)内,如果某些文件自己有改动导致更新中途中错,您可以从这文件夹提取文件手工更新。

    本次升级需要在下面文件夹写入更新文件,请注意文件夹是否有写入权限:

    ../lib/ 状态:[√正常]

    ../lib/Article/ 状态:[√正常]

    ../Public/ 状态:[√正常]

    5: 下载更新的文件到临时目录(可以直接下载压缩包在解压出文件)下载过程需要显示文件是否下载ok,完成提示安装更新按钮

    6: 点击更新首先判断是否有sql文件,有先更新sql,在更新文件

    7: 更新完成改写客户网站更新时间,并提示可以删除下载的临时更新文件

    展开全文
  • PB 自动升级远程(原创,以前项目使用过),pb9写的一个自动软件升级代码,远程网络更新。
  • 针对煤矿井下安全监控分站升级和维护难的问题,提出了一种基于LPC2114处理器的煤矿安全监控分站远程升级方案;阐述了IAP技术原理,介绍了远程升级方案的思路、实现方法以及设计时应注意的关键问题。该方案一方面可保障...
  • SQL数据库,远程执行SQL代码,有自动升级功能。
  • zabbix服务器监控客户端主机的nginx 80端口,发现端口异常自动执行远程命令处理;当远程命令执行不能解决问题时,故障状态升级并发送邮件的方式通知管理员 一、配置监控项 1、创建监控nginx 80端口 2、添加键值...

    前提:

    zabbix服务器已经搭建,并已经添加监控监控主机

    实现效果:

    zabbix服务器监控客户端主机的nginx 80端口,发现端口异常自动执行远程命令处理;当远程命令执行不能解决问题时,故障状态升级并发送邮件的方式通知管理员

    一、配置监控项

    1、创建监控nginx 80端口

    2、添加键值

    二、配置告警条件

    1、创建触发器

    3、添加告警检查表达式(返回0表示未监听:故障,1正在监听:正常)

    三、配置触发器动作

    1、创建动作

    2、添加触发器动作条件

    3、故障之后先执行第一步远程命令,持续一分钟

    4、如果故障时间超过一分钟没有解决,就告警升级执行第二步邮件告警管理员。如果已经解决就不执行第二步

    四、故障测试

    1、手动停止nginx服务

    2、查看告警,当远程命令自动执行成功,就没有告警邮件提醒,只有恢复告警邮件提醒

    3、假如远程命令执行之后没有解决问题

    4、手动恢复nginx服务,会看到故障解除邮件

    五、故障期间,每间隔多久邮件告警一次

    1、设置告警动作

    2、触发告警,看到如果不处理告警,两个小时后会自动再发送邮件

     

    展开全文
  • 自动升级系统

    2018-05-31 05:20:35
    自动检测当前程序的版本,可以选择是远程升级还是本地升级,并常驻内存,随时检测最新版本进行升级,适用于服务器端程序的版本维护。
  • vc++自动升级程序

    2020-12-26 21:35:13
    vc++自动升级程序 visual c++编写的远程自动升级程序。这是PC软件开发的必备功能啊 如何实现程序的自动升级
  • qq自动远程协助2013版

    2013-01-05 17:08:55
    花了点时间升级自动远程协助的程序,方便远程办公的同学使用。 被控qq设置: 1.qq版本为QQ2013 Beta1 2.qq系统设置为允许来消息时自动弹出窗口 3.点击软件说明旁边按钮设置主控qq用户名(被控qq消息弹出时窗口...
  • STM32远程升级设计

    2020-07-16 17:21:11
    STM32 的内部闪存地址起始于0x...1、当中断来临,STM32 的内部硬件机制亦会自动将PC 指针定到“中断向量表”处,并根据中断源取出对应的中断向量执行中断服务程序; 2、STM32 在复位后,先从0X08000004 地址取.

    STM32 的内部闪存地址起始于0x08000000。一般情况下,程序从此地址开始写入。

    由于STM32 内部是通过一张“中断向量表”来响应中断,程序启动后,将首先从“中断向量表”取出复位中断向量执行复位中断程序完成启动,而这张“中断向量表”的起始地址是0x08000004。

    中断代码响应过程简单表述如下:

    1、当中断来临,STM32 的内部硬件机制亦会自动将PC 指针定到“中断向量表”处,并根据中断源取出对应的中断向量执行中断服务程序;
    
    2、STM32 在复位后,先从0X08000004 地址取出复位中断向量的地址,并跳转到复位中断服务程序;
    
    3、在复位中断服务程序执行完之后,会跳转到我们的main 函数;
    
    4、在main 函数执行过程中,如果收到中断请求(发生重中断),此STM32 强制将PC 指针指回中断向量表处;
    
    5、根据中断源进入相应的中断服务程序;在执行完中断服务程序以后,程序再次返回main 函数执行。

    STM32管理升级的代码段习惯沿用arm的称呼,将其称为bootlader,或者IAP程序。这段代码是专门用于升级的(本身也可以把这段代码融入到正式程序中(APP程序),但是为了方便,本文将IAP和APP分开使用,防止代码交叉,升级失败处理困难)。

    加入IAP程序后,执行过程如下:

    1、STM32 复位后,还是从0X08000004 地址取出复位中断向量的地址,并跳转到复位中断服务程序;
    
    2、在运行完复位中断服务程序之后跳转到bootlader 的main 函数;
    
    3、在执行完bootlader以后,跳转至新写入程序的复位向量表,取出新程序的复位中断向量的地址,并跳转执行新程序的复位中断服务程序,随后跳转至新程序的main 函数。
    

    如此,远程升级程序必须满足两个要求:
    1、 新程序必须在bootader 程序之后的某个偏移量为x 的地址开始。
    2、 必须将新程序的中断向量表相应的移动,移动的偏移量为x。

     IAP程序实现的功能(本质上该程序也是一段单片机可运行的代码,其中也有main()函数):

    1、判断是否需要升级,如果升级,进入升级流程,如果不升级,跳转到APP执行;
    
    2、使用大数组,接收升级文件数据,每一次接收都应该有数据校验;
    
    3、将现在APP区间的代码数据备份到flash;
    
    4、把大数组中的数据写到APP的地址中;
    
    5、防止升级失败,应该设置APP无法正常运行的情况下,重新恢复原程序;
    
    6、在APP代码中添加中断向量表偏移。

    下面贴出代码:

    //设置栈顶地址
    //addr:栈顶地址
    __asm void MSR_MSP(uint32_t addr) 
    {
        MSR MSP, r0 			//set Main Stack value
        BX r14
    }
    
    //设置栈顶地址
    //addr:栈顶地址
    __asm void MSR_PSP(uint32_t addr) 
    {
        MSR PSP, r0 			//set process Stack value
        BX r14
    }
    
    //开启所有中断
    __asm void INTX_ENABLE(void)
    {
    	CPSIE   I
    	BX      LR  
    }
    
    //关闭所有中断(但是不包括fault和NMI中断)
    __asm void INTX_DISABLE(void)
    {
    	  CPSID   I
    	  BX      LR	  
    }
    typedef  void (*iapfun)(void);//定义一个函数类型的参数.
    iapfun jump2app;
    
    //跳转到应用程序段
    //appxaddr:用户代码起始地址.
    uint8_t iap_load_app(uint32_t appxaddr)
    {
    	if(((*(__IO uint32_t*)appxaddr)&0x2FF00000)==0x20000000)//检查栈顶地址是否合法.
    	{ 	
    		printf("jump to APP...\r\n");
    		jump2app=(iapfun)*(__IO uint32_t*)(appxaddr+4);//用户代码区第二个字为程序开始地址(复位地址)		
    //		MSR_PSP(*(__IO uint32_t*)appxaddr);
    //		__set_CONTROL(0);
    		MSR_MSP(*(__IO uint32_t*)appxaddr);//初始化APP堆栈指针(用户代码区的第一个字用于存放栈顶地址)
    
    		INTX_DISABLE();//关闭全部中断(但是不包括fault和NMI中断)
    		//__set_PRIMASK(1);
    //		__disable_irq();
    		__disable_fault_irq (); 
    		jump2app();//跳转到APP
    		return 0;
    	}
    	else
    	{
    		printf("jump error...\r\n");
    		return 1;
    	}
    }
    uint8_t getAppNumber(uint64_t *num)//读取升级标志位,并且擦除该页
    {
    	uint8_t state = 0;
    	uint64_t tmpbuf[4];
    	for(int i=0;i<4;i++)
    	{
    		tmpbuf[i] = *(__IO uint64_t*)(ADDR_UPDATA_START+i*8);
    		printf("tmpbuf[%d]:%lld\r\n",i,tmpbuf[i]); 
    	}
    	if((tmpbuf[0] == (~0x0))&&(tmpbuf[1] == (~0x0)))
    	{
    		printf("升级标志位中未读取到数据,亦不升级!!!\r\n");
    		*num = 0;
    		state = 0;
    //		return 0;
    	}
    	else if(tmpbuf[0] == 1)//tmpbuf[0]是升级标志位,tmpbuf[1]是iap重启次数
    	{
    		state = 1;
    	}
    	else
    		state = 0;
    	printf("升级标志位:\t%d(0不升级,1升级)\r\n",state);
    	*num = tmpbuf[1] + 1;
    	tmpbuf[0] = 0;
    	tmpbuf[1] = *num;
    	printf("IAP跳转次数:\t%lld\r\n",*num);
    	__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_OPTVERR);
    	eraseFlash(ADDR_UPDATA_START,ADDR_UPDATA_END);
    	HAL_FLASH_Unlock();
    	//tmpbuf[0]是升级标志位,tmpbuf[1]是iap重启次数
    	for(int i=0;i<2;i++)
    	{
    		if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, ADDR_UPDATA_START+8*i, (uint64_t)tmpbuf[i]) != HAL_OK)
    		{
    			HAL_FLASH_Lock();
    			return 2;
    		}
    	}
    	HAL_FLASH_Lock();
    	return state;
    }
    //获取当前APP代码的数据量,为备份该数据做准备
    uint32_t getValidByte(uint32_t start_addr,uint32_t end_addr)//获取地址中的数据量,单位双字节
    {
    	uint32_t addrNum = end_addr - start_addr + 1;
    	addrNum = addrNum / 8 * 8;
    	uint64_t data = 0;
    	do
    	{
    		addrNum -= 8;
    		data = *(__IO uint64_t*)(start_addr + addrNum);
    
    	}while((data==(~0x0))&&(addrNum>0));
    	return addrNum/8*8+8;
    }
    
    //擦除flash
    uint8_t eraseUpdateFlash(uint32_t start_addr,uint32_t end_addr)
    {
    	printf("开始擦除FLASH...");
    	__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_OPTVERR);
    	eraseFlash(start_addr,end_addr);
    	return 0;
    }
    
    //获取已经写入大数组的数据条数,该数组是一个二维数组,返回值是当前存入的数据条数
    uint16_t getLine(const uint8_t (*buf)[COLCOUNT],uint32_t length)
    {
    	int i = 0;
    	for(i=0;i<length/COLCOUNT+1;i++)
    	{
    		if(buf[i][0] != 0xDD)
    		{
    			break;
    		}
    	}
    	return i;
    }
    
    //把大数组内容写入到flash中
    uint8_t updataFlash(uint16_t rowSize,uint32_t onceSize,uint32_t start_addr,uint32_t end_addr)//把数据写入flash
    {
    	HAL_Delay(10);
    	printf("开始准备写flash...\r\n");
    	HAL_IWDG_Refresh(&hiwdg);	
    	uint64_t tmpbuf[128] = {0};
    	HAL_FLASH_Unlock();																								//准备写flash,升级
    	for(int m=0;m<rowSize;m++)
    	{
    		for(int j=1;j<onceSize+1;j = j+8)
    		{
    			tmpbuf[(j-1)/8] = ((uint64_t)updateBuf[m][j+7]<<7*8)|((uint64_t)updateBuf[m][j+6]<<6*8)|((uint64_t)updateBuf[m][j+5]<<5*8)|
    												((uint64_t)updateBuf[m][j+4]<<4*8)|((uint64_t)updateBuf[m][j+3]<<3*8)|((uint64_t)updateBuf[m][j+2]<<2*8)|
    												((uint64_t)updateBuf[m][j+1]<<1*8)|((uint64_t)updateBuf[m][j+0]<<0*8);
    			if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, start_addr+(onceSize)*m+(j-1), (uint64_t)tmpbuf[(j-1)/8]) != HAL_OK)
    			{
    				HAL_FLASH_Lock();
    				printf("flash写入失败。。。\r\n");
    				return 1;
    			}
    		}
    	}
    	HAL_FLASH_Lock();
    	HAL_IWDG_Refresh(&hiwdg);	
    	for(int m=0;m<rowSize;m++)
    	{
    		for(int j=1;j<onceSize+1;j++)
    		{
    			if(updateBuf[m][j] != *(__IO uint8_t*)(start_addr+(onceSize)*m+(j-1)))
    			{
    				printf("flash对比失败。。。\r\n");
    				return 1;
    			}
    		}
    	}
    	return 0;
    }
    
    //备份APP中的数据
    uint8_t programMove(uint32_t sour_addr,uint32_t dest_addr,uint32_t length)//转移大量flash数据,length单位双字节
    {
    	if(sour_addr == dest_addr)
    		return 1;
    	uint64_t data = 0;
    
    	eraseUpdateFlash(dest_addr,dest_addr+0x12000-1);
    
    	HAL_Delay(10);
    	HAL_FLASH_Unlock();
    	length = length/8*8+8;
    	printf("程序迁移length:%d\r\n",length);
    	for(int m=0;m<=length;m+=8)
    	{
    		data = *(__IO uint64_t*)(sour_addr + m);
    		if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, dest_addr+m, (uint64_t)data) != HAL_OK)
    		{
    			HAL_FLASH_Lock();
    			printf("flash error\r\n");
    			return 2;
    		}
    	}
    	HAL_FLASH_Lock();
    	HAL_Delay(20);
    	return 0;
    }

    main()函数中在最开始加入如下代码:

    SCB->VTOR = FLASH_BASE | 0x4000;//0x4000是偏移地址
    __enable_fault_irq();
    INTX_ENABLE();

    项目地址:https://download.csdn.net/download/sehanlingfeng/12625369

    展开全文
  • 说明:该程序与我之前编写的《STM32F407通过SD卡进行程序升级(把bin文件烧写到FLASH的方式)》程序整合起来就可以实现SD卡+网络升级,即可以通过SD卡进行程序升级,如果升级失败自动跳转 去进行网络升级,也可以...
  • 之前给单位做过一个多进程监控的自动关机工具,详见那篇blog。 这次领导又加了需求,说要等进程监控结束后,不止需要关闭主控端server,还需要关闭其他servers。于是就用到了我上篇文章所介绍的知识——通过...

    之前给单位做过一个多进程监控的自动关机工具,详见那篇blog

    这次领导又加了需求,说要等进程监控结束后,不止需要关闭主控端server,还需要关闭其他servers。于是就用到了我上篇文章所介绍的知识——通过PowerShell来远程管理计算机。

    由于PowerShell和C#都是基于.NET的,所以也不需要胶水把这两种语言粘合到一起。可以充分的利用两者各自的优点,结合到一起!(PowerShell在远程管理server这方面是很擅长的。)

    于是我修改了之前的工具UI界面,多出了两个textbox,分别用来选择server配置文件(需要关闭的除主控端的server的相关信息都记录在该配置文件中)和PowerShell脚本文件(主要负责远程方面的操作):

    server配置文件格式如下,一行对应一台server,每一行中的server ip、用户名、密码用空格隔开:

    选用的PowerShell脚本文件代码如下:

    function ShutDownRemoteComputers
    {
        param($ip,$user,$pwd)
        #winrm s winrm/config/client '@{TrustedHosts=10.1.23.60"}'
        $sen = "'@{TrustedHosts=`""+$ip+"`"}'"
        winrm s winrm/config/client $sen
        $pw = convertto-securestring -AsPlainText -Force -String $pwd
        $cred = new-object -typename System.Management.Automation.PSCredential -argumentlist $user,$pw
        $session = New-PSSession $ip -Credential $cred
        icm $session {shutdown -s -t 0}
    }

    Winform程序在主控端结束进程检查后,会先关闭server配置文件中的servers,然后关闭主控端server(本机)。

    代码如下(粉色部分为新加的和远程相关的主要内容):

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    using System.Diagnostics;
    using System.Text.RegularExpressions;
    using System.IO;
    using System.Management.Automation;
    using System.Management.Automation.Runspaces;
    
    namespace AutoShutDown2
    {
        public partial class MainForm : Form
        {
            public MainForm()
            {
                InitializeComponent();
            }
    
            private void chooseFileButton_Click(object sender, EventArgs e)
            {
                OpenFileDialog fileName = new OpenFileDialog();
                fileName.Filter = "文本文件|*.*|C#文件|*.cs|所有文件|*.*";
                if (fileName.ShowDialog() == DialogResult.OK)
                {
                    filePath.Text = fileName.FileName;
                }
            }
    
            private void filePath_Click(object sender, EventArgs e)
            {
                filePath.Text = "";
            }
    
            private void startButton_Click(object sender, EventArgs e)
            {
                if (filePath.Text.ToString().Substring(filePath.Text.Length - 3, 3) == "txt")
                {
                    if (Regex.IsMatch(duration.Text, "^([0-9]{1,})$"))
                    {
                        if (int.Parse(duration.Text) >= 30)
                        {
                            if (serverFilePath.Text == "")
                            {
                                MessageBox.Show("You should choose a server configuration file first.");
                            }
                            else
                            {
                                MessageBox.Show("PCAS will check with a duration of " + duration.Text + "s.");
                                this.Hide();
                                //Check the processes with the duration.
                                DurationStart();
                            }
                        }
                        else 
                        {
                            MessageBox.Show("The integer number should be greater than 30 seconds.");
                        }
                    }
                    else
                    {
                        MessageBox.Show("You can only type in an integer for duration.");
                        duration.Text = "";
                    }
                }
                else 
                {
                    MessageBox.Show("You can only choose a txt to be a configuration file.");
                    filePath.Text = "";
                }
            }
    
            private void DurationStart()
            {
                //Check the process's status with the duration.
                System.Timers.Timer tmr = new System.Timers.Timer(int.Parse(duration.Text)*1000);
                tmr.Elapsed += new System.Timers.ElapsedEventHandler(CheckProcess);
                tmr.AutoReset = true;
                tmr.Enabled = true;
            }
    
            private void CheckProcess(object source, System.Timers.ElapsedEventArgs e)
            {
                //Check the processes's status in the config file.
                using (FileStream fs = new FileStream(filePath.Text, FileMode.Open))
                {
                    using (StreamReader sr = new StreamReader(fs))
                    {
                        string line;
                        int numOfTheProcesses = 0;
                        while ((line = sr.ReadLine()) != null)
                        {
                            var processes = System.Diagnostics.Process.GetProcesses();
                            foreach (var process in processes)
                            {
                                if (process.ProcessName == line)
                                {
                                    //Find the objective process.
                                    //MessageBox.Show(line);
                                    numOfTheProcesses++;
                                }
                            }
                        }
                        if (numOfTheProcesses == 0)
                        {
                            //No such process, shut down the computer.
                            //MessageBox.Show("The computer is ready to be shut down.");
                            //Shut down the computer
                            ShutDown();
                        }
                        sr.Close();
                    }
                    fs.Close();
                }
            }
    
            private void ShutDown()
            {
                //Shut down the other computers.
                ShutDownOthers(serverFilePath.Text, scriptPathText.Text);
                //Shut down this computer.
                System.Diagnostics.Process myProcess = new System.Diagnostics.Process();
                myProcess.StartInfo.FileName = "cmd.exe";
                myProcess.StartInfo.UseShellExecute = false;
                myProcess.StartInfo.RedirectStandardInput = true;
                myProcess.StartInfo.RedirectStandardOutput = true;
                myProcess.StartInfo.RedirectStandardError = true;
                myProcess.StartInfo.CreateNoWindow = true;
                myProcess.Start();
                Thread.Sleep(3000);
                myProcess.StandardInput.WriteLine("shutdown -s -t 0"); 
                //MessageBox.Show("Shut down self.");
            }
    
            private void ShutDownOthers(string serverFilePath,string scriptPath)
            {
                //Read servers from the server file and shut down the servers.
                //Read the servers.
                string filePath = serverFilePath;
                using (FileStream fs1 = new FileStream(filePath, FileMode.Open))
                {
                    try
                    {
                        using (StreamReader sr1 = new StreamReader(fs1))
                        {
                            string line;
                            try
                            {
                                while ((line = sr1.ReadLine()) != null)
                                {
                                    var elements = line.Split();
                                    string ip = elements[0].ToString();
                                    string user = elements[1].ToString();
                                    string pwd = elements[2].ToString();
                                    //Shut down the server checked from the line.
                                    //Open the PowerShell.
                                    using (Runspace runspace = RunspaceFactory.CreateRunspace())
                                    {
                                        //MessageBox.Show("Run PowerShell.");
                                        string script = File.ReadAllText(scriptPath);
                                        runspace.Open();
                                        PowerShell ps = PowerShell.Create();
                                        ps.Runspace = runspace;
                                        ps.AddScript(script);
                                        ps.Invoke();
                                        ps.AddCommand("ShutDownRemoteComputers").AddParameter("ip", ip).AddParameter("user", user).AddParameter("pwd", pwd);
                                        ps.Invoke();
                                        //MessageBox.Show("Shut down others");
                                    }
                                }
                            }
                            finally
                            {
                                sr1.Close();
                            }
                        }
                    }
                    finally
                    {
                        fs1.Close();
                    }
                }       
            }
    
            private void chooseServerFileButton_Click(object sender, EventArgs e)
            {
                OpenFileDialog fileName = new OpenFileDialog();
                fileName.Filter = "文本文件|*.*|C#文件|*.cs|所有文件|*.*";
                if (fileName.ShowDialog() == DialogResult.OK)
                {
                    serverFilePath.Text = fileName.FileName;
                }
            }
    
            private void serverFilePath_Click(object sender, EventArgs e)
            {
                serverFilePath.Text = "";
            }
    
            private void scriptPathText_Click(object sender, EventArgs e)
            {
                scriptPathText.Text = "";
            }
    
            private void chooseScriptButton_Click(object sender, EventArgs e)
            {
                OpenFileDialog fileName = new OpenFileDialog();
                fileName.Filter = "文本文件|*.*|C#文件|*.cs|所有文件|*.*";
                if (fileName.ShowDialog() == DialogResult.OK)
                {
                    scriptPathText.Text = fileName.FileName;
                }
            }
        }
    }

    至于远程所需要在主控端和被控端所做的准备工作,一语概括就是在主控端和被控端都Enable-PSRemoting(全选A),然后互相配置Winrm信任就ok了(这两步都是在PowerShell中进行的,详见通过PowerShell来远程管理计算机这篇blog)。

    //Open the PowerShell.
    using (Runspace runspace = RunspaceFactory.CreateRunspace())
    {
         //MessageBox.Show("Run PowerShell.");
         string script = File.ReadAllText(scriptPath);
         runspace.Open();
         PowerShell ps = PowerShell.Create();
         ps.Runspace = runspace;
         ps.AddScript(script);
         ps.Invoke();
         ps.AddCommand("ShutDownRemoteComputers")
            .AddParameter("ip", ip)
            .AddParameter("user", user)
            .AddParameter("pwd", pwd);
         ps.Invoke();
    }

    上面这段代码就是在C#中调用PowerShell脚本的关键。想要在C#中引用PowerShell需要事先add reference:

    找到这个reference最快捷的方式就是在PowerShell中输入[psobject].Assembly.Location

    然后在代码里using相应的命名空间就可以了:

    亲测通过后获得了相关部门领导赠送的可爱多一个。

    转载于:https://www.cnblogs.com/LanTianYou/p/4727496.html

    展开全文
  • 本文仅限于技术讨论与分享,严禁用于非法用途当代社会,我们进公司需要门禁卡,出入小区需要门禁卡,门禁系统又称出入管理控制系统(ACCESS CONTROL SYSTEM), 是一种管理人员进出的智能化管理系统,它集微机自动识别...
  • 概述环保数采仪AF-HK100是专用于环境监测和污染源在线监控的数据采集、存储和传输一体化设备,是新一代无线数据采集通讯终端,专为环境在线监测监控系统研发的新型环境自动监测仪表,广泛应用污染源、地表水、空气...
  • 需要注意的是,由于部分PLC只能在局域网中实现访问,无法跨三层网络访问,此时便需要EOIP技术,建立IP 传输层之间的以太网隧道,打通网络,完成PLC的远程升级,从而实现远程控制PLC。即保证PLC和控制室的主机在同一...
  • 升级程序说明: 此版本适用于以下型号: DH-DVR2116,DH-DVR2116H,DH-DVR2116HE 特别声明:版本号:V3.200.0001.26.R.20150126,设备...请严格参考升级方法升级操作,在升级过程中,请勿断电,耐心等待设备自动重启
  • DM36x IPNC远程升级

    2014-01-13 16:23:50
    而且UBOOT在烧写和读取nandflash时,均会自动跳过坏块.这样,只要在kernel加载文件系统的时候,解决了nandflash坏块问题,系统几乎很强壮,不会出现启动到一半死机的情况. 一个系统升级的过程就是将映像文件烧写到nand...
  • 作者 1 月 25 日消息蔚来汽车官方微博今天上午宣布,蔚来 NIO OS 2.9.0 版本今日...下面是更新内容:更轻松的系统升级NIO App 远程控制 FOTA 升级随时随地,远程升级。手机端通过 NIO App 推送提醒,点击 “确认更...
  • 在控制柜安装HINET智能网关和PLC通讯,现场有西门子S7-200、S7-300、S7-1200 PLC通过以太网和HINET智能网关通讯...选用HINET智能网关除了可以监控数据,还可以远程监控PLC的程序,做项目的人都不喜欢出差,可以远程...
  • 一款很简单的远程客户端自动升级程序,一个升级程序添加到主程序bin里面,一个webservice服务部署到IIS上,就轻松搞定自动升级
  • shell自动升级脚本

    2017-09-15 15:44:17
    shell 自动升级脚本,可以实现已知要更新的文件,通过远程获取发布包进行发布,减少人工输入的出错率,可以根据自己的实际需求进行更改
  • 自从 5.2 版开始, Red Hat LINUX 便 增加了一个称为 ...本文简要地介绍了使用 Red Hat LINUX 的 kickstart 及网络安装功能方便快捷地升级己有 LINUX 系统,文中的例子是从 Red Hat 7.2 远程升级到 Red Hat 9.0。
  • 模仿抖音app,可以离线看视频,批量上传视频,调进度,右边滑动调节声音,左边翻页,自动同步更新远程上传视频,记录位置     服务器内容:   其中的video_version.txt格式内容: [{"NO":"1",...
  • 一、简介 ... 二、步骤 1、TFTP是基于UDP的协议,所以要在LWIP配置中使能LWIP功能 ...注意stm32cube自动生成的引脚可能和实际电路不匹配,要注意下。 3、配置lwip 使能UDP,使用静态Ip 4、使能TFTP ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,236
精华内容 494
关键字:

自动远程升级