背景

在使用abp vNext开发过程中，因项目使用的是ef core作为ORM工具，而Ef的批量操作性能并不能让人满意。于是便有了使用原生sql操作数据库的需求。

使用

既然说到使用了abp vNext，那肯定利用abp的功能实现更为方便。代码如下：

方式一

第一种情况，可以获取到仓储对象，Repository。无需在意哪个实体的仓储，任意实体仓储

private async Task ExecuteSql(string sql)
{
    using (var dbContext = _coursewareRepository.GetDbContext())
    {
        var aa =await dbContext.Database.ExecuteSqlRawAsync(sql);
    }
}

方式二

正常情况下，上述方式可以满足正常使用了，但是如果使用了后台任务，在后台任务中使用sql，该方式会报cannot access a disposed object的错误，提示dbContext已被释放。可通过以下方式进行使用。

private async Task ExecuteSql(string sql)
{
    using (var scope = ServiceScopeFactory.CreateScope())
    {
        var db = scope.ServiceProvider.GetService<IdeologyFrontDbContext>();
        var a = await db.Database.ExecuteSqlRawAsync(sql);
    }
}

背景

项目开发采用的是vue+abp WebApi方式，开发过程中发现有跨域问题。

解决方案

XXXHostModule类中ConfigureServices方法下添加如下代码：

var configuration = context.Services.GetConfiguration();
var hostingEnvironment = context.Services.GetHostingEnvironment();

ConfigureCors(context, configuration);

ConfigureCors方法如下：

private const string DefaultCorsPolicyName = "Default";
private void ConfigureCors(ServiceConfigurationContext context, IConfiguration configuration)
{
    context.Services.AddCors(options =>
    {
        options.AddPolicy(DefaultCorsPolicyName, builder =>
        {
            builder
                //.AllowAnyOrigin()
                .WithOrigins(
                    configuration["App:CorsOrigins"]
                        .Split(",", StringSplitOptions.RemoveEmptyEntries)
                        .Select(o => o.RemovePostFix("/"))
                        .ToArray()
                )
                .WithAbpExposedHeaders()
                .SetIsOriginAllowedToAllowWildcardSubdomains()
                .AllowAnyHeader()
                .AllowAnyMethod()
                .AllowCredentials();
        });
    });
}

XXXHostModule类中OnApplicationInitialization方法下添加如下代码：

var app = context.GetApplicationBuilder();

app.UseCors(DefaultCorsPolicyName);

appsettings.json中添加如下配置，根据需求进行添加，本示例为开发环境配置，所以加入了localhost:8080

  "App": {
    "CorsOrigins": "http://localhost:8080,http://10.10.10.144:8080,*"
  }

完成，这样就可以进行跨域访问了

背景

业务需要，通过WebApi返回视频，起初，直接在Controller读取视频信息，返回FileContentResult。大部分浏览器也能正常播放。但是会存在以下问题：

• Mac系统下safari浏览器播放视频失败。
• Html Video标签下，视频无法拖动进度，一些类似进度跳转，加载到最近一次播放进度的功能需求就无法满足。
• 视频加载缓慢，wpf或其他客户端下，一些大视频可能会加载很长时间才能播放，而且播放卡顿严重。

原因

Mac 系统Safari浏览器在加载视频是要求视频必须支持分块加载，即必须支持Range请求头，而我们直接返回FileContentResult是不支持Range的。
同样，Video标签下不能拖动进度和客户端加载视频缓慢也是这个原因。

解决

找到原因，解决问题就相对简单了，google了一番，加上GitHub搜索，找到如下方法。废话不多说，直接上代码。

VideoStreamResult类

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Net.Http.Headers;
using System;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading.Tasks;

public class VideoStreamResult : FileStreamResult
{
    // default buffer size as defined in BufferedStream type
    private const int BufferSize = 0x1000;
    private string MultipartBoundary = "<qwe123>";

    public VideoStreamResult(Stream fileStream, string contentType)
        : base(fileStream, contentType)
    {

    }

    public VideoStreamResult(Stream fileStream, MediaTypeHeaderValue contentType)
        : base(fileStream, contentType)
    {

    }

    private bool IsMultipartRequest(RangeHeaderValue range)
    {
        return range != null && range.Ranges != null && range.Ranges.Count > 1;
    }

    private bool IsRangeRequest(RangeHeaderValue range)
    {
        return range != null && range.Ranges != null && range.Ranges.Count > 0;
    }

    protected async Task WriteVideoAsync(HttpResponse response)
    {
        var bufferingFeature = response.HttpContext.Features.Get<IHttpResponseBodyFeature>();
        bufferingFeature?.DisableBuffering();

        var length = FileStream.Length;

        var range = response.HttpContext.GetRanges(length);

        if (IsMultipartRequest(range))
        {
            response.ContentType = $"multipart/byteranges; boundary={MultipartBoundary}";
        }
        else
        {
            response.ContentType = ContentType.ToString();
        }

        response.Headers.Add("Accept-Ranges", "bytes");

        if (IsRangeRequest(range))
        {
            response.StatusCode = (int)HttpStatusCode.PartialContent;

            if (!IsMultipartRequest(range))
            {
                response.Headers.Add("Content-Range", $"bytes {range.Ranges.First().From}-{range.Ranges.First().To}/{length}");
            }

            foreach (var rangeValue in range.Ranges)
            {
                if (IsMultipartRequest(range)) // dunno if multipart works
                {
                    await response.WriteAsync($"--{MultipartBoundary}");
                    await response.WriteAsync(Environment.NewLine);
                    await response.WriteAsync($"Content-type: {ContentType}");
                    await response.WriteAsync(Environment.NewLine);
                    await response.WriteAsync($"Content-Range: bytes {range.Ranges.First().From}-{range.Ranges.First().To}/{length}");
                    await response.WriteAsync(Environment.NewLine);
                }

                await WriteDataToResponseBody(rangeValue, response);

                if (IsMultipartRequest(range))
                {
                    await response.WriteAsync(Environment.NewLine);
                }
            }

            if (IsMultipartRequest(range))
            {
                await response.WriteAsync($"--{MultipartBoundary}--");
                await response.WriteAsync(Environment.NewLine);
            }
        }
        else
        {
            await FileStream.CopyToAsync(response.Body);
        }
    }

    private async Task WriteDataToResponseBody(RangeItemHeaderValue rangeValue, HttpResponse response)
    {
        var startIndex = rangeValue.From ?? 0;
        var endIndex = rangeValue.To ?? 0;

        byte[] buffer = new byte[BufferSize];
        long totalToSend = endIndex - startIndex;
        int count = 0;

        long bytesRemaining = totalToSend + 1;
        response.ContentLength = bytesRemaining;

        FileStream.Seek(startIndex, SeekOrigin.Begin);

        while (bytesRemaining > 0)
        {
            try
            {
                if (bytesRemaining <= buffer.Length)
                    count = FileStream.Read(buffer, 0, (int)bytesRemaining);
                else
                    count = FileStream.Read(buffer, 0, buffer.Length);

                if (count == 0)
                    return;

                await response.Body.WriteAsync(buffer, 0, count);

                bytesRemaining -= count;
            }
            catch (IndexOutOfRangeException)
            {
                await response.Body.FlushAsync();
                return;
            }
            finally
            {
                await response.Body.FlushAsync();
            }
        }
    }

    public override async Task ExecuteResultAsync(ActionContext context)
    {
        await WriteVideoAsync(context.HttpContext.Response);
    }
}

这里使用了一个扩展方法：

public static RangeHeaderValue GetRanges(this HttpContext context, long contentSize)
{
    RangeHeaderValue rangesResult = null;

    string rangeHeader = context.Request.Headers["Range"];

    if (!string.IsNullOrEmpty(rangeHeader))
    {
        string[] ranges = rangeHeader.Replace("bytes=", string.Empty).Split(",".ToCharArray());

        rangesResult = new RangeHeaderValue();

        for (int i = 0; i < ranges.Length; i++)
        {
            const int START = 0, END = 1;

            long endByte, startByte;

            long parsedValue;

            string[] currentRange = ranges[i].Split("-".ToCharArray());

            if (long.TryParse(currentRange[END], out parsedValue))
                endByte = parsedValue;
            else
                endByte = contentSize - 1;


            if (long.TryParse(currentRange[START], out parsedValue))
                startByte = parsedValue;
            else
            {
                startByte = contentSize - endByte;
                endByte = contentSize - 1;
            }

            rangesResult.Ranges.Add(new RangeItemHeaderValue(startByte, endByte));
        }
    }

    return rangesResult;
}

在Controller中使用：

public async Task<ActionResult> DownloadById(string filepath)
{
    ///根据业务，获取文件Stream
    var stream = new FileStream(filepath, FileMode.Open, FileAccess.Read);
    return new VideoStreamResult(stream, mimeType);
}

背景

项目开发过程中，需要在Application层使用当前用户的Username和Name，然而查看CurrentUser发现，Name属性竟然为null，而UserName正常显示。

处理

查看了AuthServer的数据初始化代码，也没发现什么问题，

明明已经添加了name的Claim，但是却无法显示，而Email则正常显示。于是猜测可能是这里的名为name的Claim并非CurrentUser中的Name属性。为了验证，我查看了abp vNext的源码，找到了AbpUserClaimsPrincipalFactory 类，代码如下：

 public class AbpUserClaimsPrincipalFactory : UserClaimsPrincipalFactory<IdentityUser, IdentityRole>, ITransientDependency
    {
        public AbpUserClaimsPrincipalFactory(
            UserManager<IdentityUser> userManager,
            RoleManager<IdentityRole> roleManager,
            IOptions<IdentityOptions> options)
            : base(
                  userManager,
                  roleManager,
                  options)
        {
        }

        [UnitOfWork]
        public async override Task<ClaimsPrincipal> CreateAsync(IdentityUser user)
        {
            var principal = await base.CreateAsync(user);
            var identity = principal.Identities.First();

            if (user.TenantId.HasValue)
            {
                identity.AddIfNotContains(new Claim(AbpClaimTypes.TenantId, user.TenantId.ToString()));
            }

            if (!user.Name.IsNullOrWhiteSpace())
            {
                identity.AddIfNotContains(new Claim(AbpClaimTypes.Name, user.Name));
            }

            if (!user.Surname.IsNullOrWhiteSpace())
            {
                identity.AddIfNotContains(new Claim(AbpClaimTypes.SurName, user.Surname));
            }

            if (!user.PhoneNumber.IsNullOrWhiteSpace())
            {
                identity.AddIfNotContains(new Claim(AbpClaimTypes.PhoneNumber, user.PhoneNumber));
            }

            identity.AddIfNotContains(new Claim(AbpClaimTypes.PhoneNumberVerified, user.PhoneNumberConfirmed.ToString()));

            if (!user.Email.IsNullOrWhiteSpace())
            {
                identity.AddIfNotContains(new Claim(AbpClaimTypes.Email, user.Email));
            }

            identity.AddIfNotContains(new Claim(AbpClaimTypes.EmailVerified, user.EmailConfirmed.ToString()));

            return principal;
        }
    }
}

## 解决方案

这里，我们看到了 AbpClaimTypes.Name 的名称，此名称应该为Name的Claim名称，我直接将其添加到了commonApiUserClaims列表中，发现命名空间下没有该属性，当时Apb版本为3.0.5，升级至3.2.1后，已经可以使用，o(╯□╰)o。之后再次调试，发现已经可以获得Name属性了。

 private async Task CreateApiResourcesAsync()
        {
            var commonApiUserClaims = new[]
            {
                //"email",
                //"email_verified",
                "name",
                //"phone_number",
                //"phone_number_verified",
                //"role",
                AbpClaimTypes.Name
            };

            await CreateApiResourceAsync("IdentityService", commonApiUserClaims);
            await CreateApiResourceAsync("InternalGateway", commonApiUserClaims);
            await CreateApiResourceAsync("WebAppGateway", commonApiUserClaims);
            //await CreateApiResourceAsync("TenantService", commonApiUserClaims);
            await CreateApiResourceAsync("IdeologyFrontService", commonApiUserClaims);
        }

1、准备工作

升级系统

$ sudo yum clean all
$ sudo yum update

查看系统版本
$ cat /etc/redhat-release

检查是否安装wget命令，后面会用到

如未安装，使用以下命令进行安装
yum install -y wget

切换yum源，不然可能会太慢

备份源文件
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
下载新的源，以下两个任选一个即可
阿里的：wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
网易的：wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.163.com/.help/CentOS7-Base-163.repo
清除系统yum缓存，并且将服务器上的软件包信息重新生成缓存到本地
yum clean all
yum makecache
更新yum
yum update -y

2、安装docker

安装所需的包 yum-utils
yum install -y yum-utils device-mapper-persistent-data lvm2

设置阿里云稳定版本的docker的源
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

centos8默认使用podman代替docker，所以需要containerd.io
yum install https://download.docker.com/linux/fedora/30/x86_64/stable/Packages/containerd.io-1.2.6-3.3.fc30.x86_64.rpm

安装最新稳定版的docker-ce
yum install docker-ce docker-ce-cli containerd.io

启动并加入开机启动
$ sudo systemctl start docker
$ sudo systemctl enable docker

验证安装是否成功(有client和service两部分表示docker安装启动都成功了)
$ docker version

docker-compose版本选择

curl -L https://github.com/docker/compose/releases/download/1.26.2/docker-compose-uname -s-uname -m -o /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

查看docker-compose版本
docker-compose version

3、安装Jenkins

安装JDK

yum install -y java

安装git

因我们需要在jenkins中配置git，所以需要安装，如不需，可不安装
yum install git
查看版本
git --version

添加Jenkins库到yum库

Jenkins将从这里下载安装
wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins-ci.org/redhat/jenkins.repo
sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key

安装jenkins

yum install -y jenkins
安装过程完成后，启动Jenkins服务并启用它以在系统引导时启动

sudo systemctl start jenkins

sudo systemctl enable jenkins

端口默认8080，如需修改端口号：
配置jenkis的端口
vi /etc/sysconfig/jenkins
找到修改端口号：
JENKINS_PORT="8080"

4.配置Jenkins

gitlab创建账号，用于jenkins使用

根据你再jenkins中配置的令牌方式不同，需要在gitlab中生成访问令牌。我自己试了几次，都有问题，干脆直接在jenkins中配置了gitlab的用户名和密码，所以这里只创建了账号，配置下项目的角色权限就OK了，没有其他操作了

安装插件

• Git Parameter ( 用于参数化构建中动态获取项目分支 )
• Generic Webhook Trigger ( 用于解析 Webhook 传过来的参数 )
• GitLab ( 用于推送构建结果给 GitLab )
  安装插件的方法，如下图：

找到插件管理界面

如图所示进行搜索安装

5、添加项目部署

新建项目

选择FreeStyle project 类型

填写源码管理

如图所示，因为我们尚未配置和选择Credentials，所以会如出现下面红色的错误，选择添加-Jenkins，进行配置凭证，

添加过程如下，我直接使用了账号密码方式，所以设置如下，如果你需要使用 gitlab pai token 方式，还需要到gitlab进行配置，具体自行google。

保存后，返回选择我们刚创建的credentials即可。
这里需要注意一点，如果你的gitlab地址是https协议的，配置完成后提示git server certificate verification failed,CAfile: none CRLfile: none错误，那么需要在配置关闭git的全局ssl验证。在Jenkins所在服务器执行如下命令

git config --global http.sslVerify false

因我的Jenkins采用docker部署，所需要先进入docker容器在执行：

[root@localhost ~]# docker exec -it jenkins /bin/bash
jenkins@b48982ee1421:/$ git config --global http.sslVerify false

编写Shell脚本

构建项目中，我们选择执行shell脚本，

因我不想在服务器上编译程序，所以我选择了在本地编译发布后，将发布文件夹也上传到gitlab中，虽然这样不是很好，但首先提高了Jenkins部署效率，而且省去了好多的gitlab配置。

脚本如下：

#!/bin/sh
cd /var/lib/jenkins/workspace/test-auth/testAuthServer.Host
docker container prune << EOF
y
EOF
docker container ls -a | grep "test-auth"
if [ $? -eq 0 ];then
    docker container stop test-auth
    docker container rm test-auth
fi
docker image prune << EOF
y
EOF

docker build -t test-auth .
docker run -d -p 5001:80 --name=test-auth test-auth

DockerFile文件如下：

FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-buster-slim AS base
WORKDIR /app
EXPOSE 80

COPY /bin/Release/netcoreapp3.1/publish .
ENTRYPOINT ["dotnet", "testAuthServer.Host.dll"]

然后再修改其他项目配置文件，并部署其他项目。

6、其他

docker安装redis

docker pull redis:latest
docker run -itd -d --name redis-test -p 6379:6379 redis

防火墙开放端口

查看当前已经开放的端口：

firewall-cmd --list-ports
开启端口，以8888为例：

firewall-cmd --zone=public --add-port=8888/tcp --permanent
重启防火墙：

firewall-cmd --reload

Nginx安装

https://www.cnblogs.com/zhizihuakai/p/12055618.html

sudo /usr/local/nginx/nginx         # 启动
/usr/local/nginx/nginx -s reload    # 重新载入配置文件
/usr/local/nginx/nginx -s reopen    # 重启 Nginx
/usr/local/nginx/nginx -s stop      # 停止 Nginx