小编Ish*_*are的帖子

我正在尝试创建一个将在服务器上远程执行的执行环境/ shell,它将stdout,err,流入套接字以在浏览器中呈现.我目前已经尝试过使用subprocess.runa 的方法PIPE.问题是我在进程完成后得到了stdout.我想要实现的是获得逐行,伪终端类型的实现.

我目前的实施

test.py

def greeter():
    for _ in range(10):
        print('hello world')

greeter()

并在壳中

>>> import subprocess
>>> result = subprocess.run(['python3', 'test.py'], stdout=subprocess.PIPE)
>>> print(result.stdout.decode('utf-8'))
hello world
hello world
hello world
hello world
hello world
hello world
hello world
hello world
hello world
hello world

如果我尝试尝试这个简单的实现pty,如何做到这一点？

我有以下模型：

  172  class ReportRecord(db.Model):                                                                                                                                                                                
  173     __tablename__ = 'tb_report_record'                                                                                                                                                                         174                                                                                                                                                                                                                175     id = db.Column(Integer, primary_key=True)                                                                                                                                                                
  176     report_id = db.Column(ForeignKey('tb_rua_report.id'), index=True)                                                                                                                                        
  177     source_ip = db.Column(String(100, 'utf8_bin'))                                                                                                                                                           
  178     count = db.Column(Integer)                                                                                                                                                                               
  179     disposition = db.Column(String(10, 'utf8_bin'))                                                                                                                                                          
  180     header_from = db.Column(String(100, 'utf8_bin'))                                                                                                                                                         
  181     spf_domain = db.Column(String(100, 'utf8_bin'))                                                                                                                                                          
  182     spf_result = db.Column(String(10, 'utf8_bin'))                                                                                                                                                           
  183     dkim_domain = db.Column(String(100, 'utf8_bin'))                                                                                                                                                         
  184     dkim_result = db.Column(String(10, 'utf8_bin'))                                                                                                                                                          
  185     isActive = db.Column(Integer, nullable=False, server_default=text("'1'"))                                                                                                                                  186     created_by = db.Column(String(100), nullable=False, server_default=text("'System'"))                                                                                                                     
  187     created_dt = db.Column(DateTime, nullable=False)                                                                                                                                                         
  188     last_modified_by = db.Column(String(100), nullable=False, …

我正在尝试使用certbot/certbotkubernetes中的docker容器生成SSL证书.我正在使用Job控制器,这看起来是最合适的选择.当我运行独立选项时,我收到以下错误:

授权程序失败.staging.ishankhare.com(http-01):urn:ietf:params:acme:error:connection ::服务器无法连接到客户端以验证域名::获取 http://staging.ishankhare.com/.众所周知/ acme-challenge/tpumqbcDWudT7EBsgC7IvtSzZvMAuooQ3PmSPh9yng8:连接超时(可能是防火墙问题)

我已经确保这不是由于运行简单的nginx容器而错误配置的DNS条目,并且它正确解析.以下是我的Jobs档案:

apiVersion: batch/v1
kind: Job
metadata:
  #labels:
  #  app: certbot-generator
  name: certbot
spec:
  template:
    metadata:
      labels:
        app: certbot-generate
    spec:
      volumes:
        - name: certs
      containers:
        - name: certbot
          image: certbot/certbot
          command: ["certbot"]
          #command: ["yes"]
          args: ["certonly", "--noninteractive", "--agree-tos", "--staging", "--standalone", "-d", "staging.ishankhare.com", "-m", "me@ishankhare.com"]

          volumeMounts:
            - name: certs
              mountPath: "/etc/letsencrypt/"
              #- name: certs
              #mountPath: "/opt/"
          ports:
            - containerPort: 80
            - containerPort: 443
      restartPolicy: "OnFailure"

和我的服务:

apiVersion: v1
kind: …

目前我看到以下库可用于使用带烧瓶的websockets:

1. 烧瓶插座(可能已过时)
2. 烧瓶SocketIO
3. gevent-websockets(2以上取决于此)

然而gevent-websockets还没有python3兼容(至少它不能通过pip安装).这使得其他2也无法使用.

使用带有烧瓶的腹板有没有其他替代方案？还是龙卷风是最好的选择？

我的build.gradle包裹有以下文件

buildscript {
    ext.kotlin_version = '1.2.21'

    repositories {
        jcenter()
        mavenCentral()
    }

    dependencies {
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    classpath "org.jetbrains.kotlin:kotlin-stdlib"
    }
}

plugins {
    id "org.jetbrains.kotlin.jvm" version "1.2.21"
}

sourceSets {
    main.kotlin.srcDirs += "./"
}

在运行时gradle compileKotlin，出现以下错误

Starting a Gradle Daemon (subsequent builds will be faster)                                                                                                                                                           
e: /home/ishan/code/kotlin-server/server/ConnectionHandler.kt: (26, 35): Too many arguments for public constructor String() defined in kotlin.String                                                                  
e: /home/ishan/code/kotlin-server/server/ConnectionHandler.kt: (26, 38): Unresolved reference: trim                                                                                                                   
e: /home/ishan/code/kotlin-server/server/ConnectionHandler.kt: (30, 29): Unresolved reference: isEmpty                                                                                                                
e: /home/ishan/code/kotlin-server/server/ConnectionHandler.kt: (40, 9): Unresolved …

在使用此处的快速入门尝试电子时。我遇到了一个奇怪的问题。在谷歌上搜索没有结果。

以下是我的目录树

。
\n\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 index.html
\n\xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80 main.js
\n\xe2 \x94\x9c\xe2\x94\x80\xe2\x94\x80 节点模块
\n\xe2\x94\x82\xc2\xa0\xc2\xa0\xe2\x94\x94\xe2\x94\x80\xe2\x94\ x80 电子预建
\n\xe2\x94\x94\xe2\x94\x80\xe2\x94\x80 package.json

的内容package.json

{\n  "name": "desktop-widget",\n  "version": "1.0.0",\n  "main": "main.js",\n  "scripts": {\n    "test": "echo \\"Error: no test specified\\" && exit 1"\n  },\n  "author": "",\n  "license": "ISC",\n  "dependencies": {\n    "electron": "^0.4.1",\n    "electron-prebuilt": "^0.36.7"\n  },\n  "devDependencies": {},\n  "description": ""\n}\n

的内容main.js

\'use strict\';\n\nconst electron      = require(\'electron\');\nconst app           = electron.app;\nconst BrowserWindow = electron.BrowserWindow;\n\nvar mainWindow = null;\n\napp.on(\'ready\', function() {\n    mainWindow = BrowserWindow({width: 800, …

我有以下循环依赖:

            $http
            /   \
           /     \
          /       \
         /         \
LoginManager------Interceptor
 (service)         (factory)

这个循环依赖只在我添加了Interceptor的代码后才出现.

InterceptorLoginManager如果某个response被截获,将调用注销功能.

从我看到的,唯一的解决方案是将拦截器代码移动到LoginManager服务中anonymous factory

有没有更好的方法？

我正在尝试定义一个模型，其中一列是mysql json type. 在 Web 上搜索与 djangopostgresql对 JSONField 类型或django-jsonfield的支持相关的建议。

目前 django 是否没有办法原生支持 mysql 的 json 类型。此外，在 mysql 中执行类型inspectdb的列时，json分配了TextField带有注释的类型This field type is a guess.

我将如何以支持 json 字段的方式声明我的模型？

我正在使用正则表达式尝试一些字符串操作,但我没有得到预期的输出

var myString = "/api/<user_id:int>/"
myString.replace(Regex("<user_id:int>"), "(\\d+)")

这应该给我一些类似/api/(\d+)/但我得到的东西/api/(d+)/

但是,如果我直接创建一个转义字符串,就像var a = "\d+"
我得到正确的输出\d+(我可以进一步用来创建一个正则表达式模式)
这是因为这种方式String::replace有效吗？
如果是这样,这不是一个错误,为什么它会删除我的转义序列？

我试图通过以下方式返回当前登录用户的详细信息：

from .serializers import UserSerializer

class UserDetailsView(RetrieveAPIView):                                                                                                                                                                           
    model = User                                                                                                                                                                                                  
    queryset = User.objects.all()                                                                                                                                                                                 
    permission_classes = [permissions.IsAuthenticated]                                                                                                                                                            
    serializer_class = UserSerializer                                                                                                                                                                             

    def get(self, request, *args, **kwargs):                                                                                                                                                                      
        user = User.objects.get(id=request.user.id)                                                                                                                                                               
        print(user)                                                                                                                                                                                               
        return Response(user)

在 serializers.py 我使用过 ModelSerializer

class UserSerializer(serializers.ModelSerializer):                                                                                                                                                                
      password = serializers.CharField(write_only=True)                                                                                                                                                             

      def create(self, validated_data):                                                                                                                                                                             
          user = UserModel.objects.create(username=validated_data['username'])                                                                                                                                      
          user.set_password(validated_data['password'])                                                                                                                                                             
          user.save()                                                                                                                                                                                               
          return user                                                                                                                                                                                               

      class Meta:                                                                                                                                                                                                   
          model = UserModel                                                                                                                                                                                         
          fields = ('id', 'username', 'password')                                                                                                                                                                   
          write_only_fields = ('password',)

我收到一个错误Object of type 'User' is not JSON serializable。我的用例有什么问题？

在我的urls.py我有：

url(r'^dashboard/users/(?P<user_id>[0-9]+)/products/$', views.UserProductsList.as_view())

在 views.py

class UserProductsList(generics.ListCreateAPIView):
     def get_queryset(self):
         if self.request.user_id:
             return UserProducts.objects.filter(user_id=self.request.user_id).order_by('id')
         else:
             return UserProducts.objects.all().order_by('id')

我希望能够像这样访问我的api：

http：// localhost：8000 / dashboard / users / 10 / products

应该列出该用户的所有产品，并且

http：// localhost：8000 / dashboard / users / 10 / products / 1

应该返回user_id 10的product_id 1

我如何实现此流程。

注意：我在此设置中使用Django rest框架

我正在使用具有自动完成选项的materializecss芯片，并使用ajax设置自动完成数据。该文档显示使用以下语法设置基本标签：

$('.chips-autocomplete').chips({
    autocompleteOptions: {
      data: {
        'Apple': null,
        'Microsoft': null,
        'Google': null
      },
      limit: Infinity,
      minLength: 1
    }
  });

但是，当我实际上要使用这些标签时，除了标签的名称（例如ID）之外，我还需要一些其他数据，以便我可以PATCH对该id字段进行请求。我目前无法实现这一目标。

如果我这样做：

autocompleteOptions: {
      data: {
        'golang': {
          tag: 'golang',
          id: 1
        },
        'docker': {
          tag: 'docker',
          id: 2
        },
        'kubernetes': {
          tag: 'kubernetes',
          id: 3
        }
      },
      minLength: 2
    },

我的自动填充字段显示不正确：

同样，onChipAdd回调函数不会接收具有完整数据的芯片，而只会显示如下：

{
  tag: 'golang'
}

是否有可能在实现过程中实现这一目标？

我有一个模型JSONField。

model.py

class Categories(models.Model):
     type = models.CharField(max_length=20)
     name = models.CharField(max_length=500)
     details = JSONField(blank=True, null=True)

目前，我正在使用serializers.ModelSerializer上述模型进行序列化：

serializers.py

class CategoriesSerializer(serializers.ModelSerializer):
     class Meta:
         model = Categories
         fields = ('id', 'type', 'name', 'details')

因此，仅检查details字段包含valid json。我真正需要做的是基于为详细信息字段定义的Json Schema执行一些自定义验证。但是，由于我不希望对其余字段进行任何其他自定义验证，因此我想继续使用所提供的验证serializers.ModelSerializer。我有什么办法可以只为一个字段覆盖一个验证，而可能只为details字段编写一个自定义序列化程序？

注意问题不是关于如何编写自定义验证器，而是关于如何在继承自序列化器的字段上使用该自定义验证器 ModelSerializer