标签: apollo

我需要创建一个服务器场,可以处理500多万个连接,500多万个主题(每个客户端一个),处理300k消息/秒.

我试图了解各种消息代理的功能,因此我目前正在使用两个RHEL EC2实例(r3.4xlarge)来创建大量可用资源.所以你不需要查找它,它有16vCPU,122GB RAM.我没有接近使用限制.

我无法通过600k连接限制.因为在客户端和服务器上似乎没有任何O/S限制(大量的RAM/CPU /等)限制了我？

我编辑了/etc/security/limits.conf如下:

* soft  nofile  20000000
* hard  nofile  20000000

* soft  nproc  20000000
* hard  nproc  20000000

root  soft  nofile 20000000
root  hard  nofile 20000000

我编辑了/etc/sysctl.conf如下:

net.ipv4.ip_local_port_range = 1024 65535  
net.ipv4.tcp_tw_reuse = 1 
net.ipv4.tcp_mem = 5242880  5242880 5242880 
net.ipv4.tcp_tw_recycle = 1 
fs.file-max = 20000000 
fs.nr_open = 20000000 
net.ipv4.tcp_syncookies = 0

net.ipv4.tcp_max_syn_backlog = 10000 
net.ipv4.tcp_synack_retries = 3 
net.core.somaxconn=65536 
net.core.netdev_max_backlog=100000 
net.core.optmem_max = 20480000

对于Apollo:导出APOLLO_ULIMIT = 20000000

对于ActiveMQ:

ACTIVEMQ_OPTS="$ACTIVEMQ_OPTS -Dorg.apache.activemq.UseDedicatedTaskRunner=false"
ACTIVEMQ_OPTS_MEMORY="-Xms50G -Xmx115G"

我在客户端为eth0创建了20个额外的私有地址,然后分配它们:ip addr add 11.22.33.44/24 dev …

我对如何构建我的 React/GraphQL (Apollo) 应用程序感到有点困惑，因为在用户验证/登录之前不应建立连接。

目前我有这个：

class App extends Component {
  render() {
    return (
      <ApolloProvider client={client}>
        <Provider store={store}>
          <Router>
            <div>
              <ul>
                <li><Link to="/">Home</Link></li>
                <li><Link to="/login">Log In</Link></li>
                <li><Link to="/signup">Sign Up</Link></li>
              </ul>
              <AuthenticatedRoute exact path="/" component={HomePage} />
              <Route path="/login" component={LoginPage} />
              <Route path="/signup" component={SignupPage} />
            </div>
          </Router>
        </Provider>
      </ApolloProvider>
    );
  }
}

这是网络接口的创建：

const networkInterface = createNetworkInterface({
  uri: process.env.NODE_ENV === 'development'
    ? 'http://localhost:3000/graphql'
    : 'TBD',
});

networkInterface.use([
  {
    applyMiddleware(req, next) {
      if (!req.options.headers) {
        req.options.headers = {}; // Create the header object …

我正在尝试按照如何在GraphQL上的本教程设置一个graphcool订阅/ websockets，但收到以下消息：

WebSocket与“ wss：//subscriptions.graph.cool/v1/###”的连接失败：WebSocket在建立连接之前已关闭。

我似乎已经按照教程掌握了所有内容。您知道为什么未建立websockets连接吗？

index.js

import React from 'react'
import ReactDOM from 'react-dom'
import App from './components/App'
import registerServiceWorker from './registerServiceWorker'
import './styles/index.css'
import { ApolloProvider, createNetworkInterface, ApolloClient } from 'react-apollo'
import { SubscriptionClient, addGraphQLSubscriptions } from 'subscriptions-transport-ws'
import { BrowserRouter } from 'react-router-dom'
import { GC_AUTH_TOKEN } from './constants'

const networkInterface = createNetworkInterface({
  uri: 'https://api.graph.cool/simple/v1/###'
})

const wsClient = new SubscriptionClient('wss://subscriptions.graph.cool/v1/###', {
  reconnect: true,
  connectionParams: {
     authToken: localStorage.getItem(GC_AUTH_TOKEN),
  }
})

const networkInterfaceWithSubscriptions = addGraphQLSubscriptions(
  networkInterface,
  wsClient …

(这是对https://github.com/apollographql/apollo-client/issues/1886的跟进)

我正在尝试构建一个文本输入,它将在用户输入时更新值.

第一次尝试

我首先尝试使用optimisticResponse更新本地缓存作为用户类型.这是有效的,除了它会在每次击键时触发突变.除了通过请求充斥网络之外,还存在网络不一致的问题.最后一个突变可能首先到达,第一个突变最后到达.这导致服务器以过时值结束.以下是此竞争条件的示例:

type: a
mutate request: a
type: b
mutate request: ab
arrives on server: ab
arrives on server: a

现在服务器在graphql中记录了"a",这是不正确的.

添加去抖动

为了缓解这个问题,我对按键事件进行了辩论.虽然这确实有助于上述竞争条件,但它并没有解决它.如果网络比你的去抖阈值慢,那么仍有可能出现竞争条件.

因为我们现在正在对文本输入进行去抖动,所以我们需要向该React组件引入一个本地状态,以便在用户输入时立即更新(如github问题中建议的@jbaxleyiii).现在我们的状态位于两个位置(组件状态和apollo缓存).

这个问题的一个大问题是组件在收到新道具时不会更新.例如.当graphql更新并推送到客户端时.

添加网络队列

因为debounce实际上并没有解决竞争条件,所以我添加了一个网络队列(除了去抖动),它将管理变异请求,以确保一次只有一个变异.如果在飞行中有一个突变请求时它会收到突变请求,它会将它排队等待第一个返回时被触发.如果已经有一个排队的突变,它将丢弃它并将其替换为新的突变(一次只能有一个项目在队列中).这是一个例子:

type: a
send mutate request: a
type: b
queues mutate request: ab     <<  wait to send this until "a" comes back
type: c
replaces queued request: abc  << discard the queued request for "ab", it's old now
response from server: a
send mutate request: abc …

我正在构建一个应用程序:

• MySQL作为后端数据库
• Apollo GraphQL服务器作为该数据库的查询层
• Sequelize作为GraphQL和MySQL之间的ORM层

当我构建我的GraphQL架构时,我使用GraphQL ID数据类型来唯一地标识记录.这是一个示例模式及其MySQL解析器/连接器

Graphql类型:

type Person {
  id: ID!
  firstName: String
  middleName: String
  lastName: String
  createdAt: String
  updatedAt: String
}

Sequelize连接器

export const Person = sequelize.define('person', {
  firstName: { type: Sequelize.STRING },
  middleName: { type: Sequelize.STRING },
  lastName: { type: Sequelize.STRING },
});

GraphQL解析器:

Query: {
  person(_, args) {
    return Person.findById(args.id);
}

这一切都有效.这是我的问题.GraphQL似乎将ID类型视为字符串.而ID值则作为INTSequelize 存储在MySQL数据库中.我可以使用GraphQL使用与数据库中的ID值匹配的字符串或整数来查询MySQL数据库.但是,GraphQL将始终将ID值作为字符串返回.

我该如何在客户端处理这个值？一旦我从GraphQL获得它,我是否应该始终将其转换为整数？我应该修改我的续集代码以将ID值存储为字符串吗？使用像这样的GraphQL ID时是否有正确的方法？

所以我有这两个模式

Schema1

type Permission {
    relation: Relation
}

enum Relation {
    ONE
    TWO
    THREE
}

SCHEMA2

type Permission {
    relation: Relation
}

enum Relation {
    FOUR
    FIVE
    SIX
}  

预期结果类似于:(但我对不同的想法持开放态度)合并后我想做的查询是:

{
    permissions{
        relation
    }
}

得到一个结果

"permissions": [
  {
    "relation": "ONE"
  },
  {
    "relation": "SIX"
  }
]

要么

"permissions": [
  {
    "relation": "schema1ONE"
  },
  {
    "relation": "schema2SIX"
  }
]

和突变像:

mutation{
  createPermission(
    relation: ONE
  ){
    relation
  }
}

mutation{
  createPermission(
    relation: SIX
  ){
    relation
  }
}

要么

mutation{
  createPermission(
    relation: …

我在我的 Apollo Client 代码中随机得到了这个。我正在使用使用 isMounted 标志包围所有 setState 的反模式，以防止在卸载组件或用户离开页面时尝试设置状态。但我仍然得到这个

Store reset while query was in flight (not completed in link chain)

是什么赋予了？

有人能解释一下，为什么当我尝试使用返回错误的突变时，为什么我的反应应用程序 + 阿波罗的行为是这样的？

GraphQL 突变返回这个（响应代码是 200）： {"errors":[{"error":{"result":"identity.not-found","error":"authentication-failed","statusCode":401}}],"data":{"login":null}}

我的突变看起来像这样：

export const LOGIN_MUTATION = gql`
    mutation($input: LoginInput!) {
        login(input: $input) {
            token
        }
    }
`;

称为：

const handleSignIn = () => {
        loginMutation({
            variables: {
                input: {
                    clientId: config.clientId,
                    username: userName,
                    password: password,
                    clientSecret: config.clientSecret
                }
            }
        });
    };

它会像预期的那样运行一段时间（呈现我自己的自定义错误组件 - {error && <div>error</div>}），但随后它抛出了这种未经处理的拒绝。

如果我将 catch 回调添加到突变调用，它会按预期工作。

但是，我没有在 apollo 文档中找到任何关于始终以这种方式捕获 GraphQL 错误的必要性的提及。如果我理解正确，这应该足够了：const[loginMutation, {data, loading, error}] = useMutation(LOGIN_MUTATION);

这种行为是正确的还是我错过了什么？

版本：

"@apollo/react-hooks": "^3.1.3"
"apollo-boost": "^0.4.7"
"graphql": "^14.5.8"

使用项目构建（或简单的 Gradle 同步），我有以下错误：

引起：java.lang.NoClassDefFoundError：无法初始化类org.jetbrains.kotlin.gradle.plugin.sources.DefaultKotlinSourceSetKt

将 gradle 包装器版本从 4.10 更改为 6.2.2 后显示此错误（因为最小 gradle 包装器版本需要 5.6.4，但在 5.6.4 Apollo 中，构建文件夹出现错误“拒绝访问”）

抱歉有错误，我的英语很糟糕（

我的 build.gradle：

apply plugin: 'com.android.application'

apply plugin: 'kotlin-android'

apply plugin: 'kotlin-android-extensions'

apply plugin: 'com.apollographql.android'

apply plugin: 'io.fabric'

apply plugin: 'com.google.gms.google-services'
apply plugin: 'org.jetbrains.dokka'
repositories {
    mavenCentral()
    maven { url 'https://maven.fabric.io/public' }
}

android {
    compileSdkVersion project.ext.compileSdkVersion

    defaultConfig {
        applicationId project.ext.applicationId
        minSdkVersion project.ext.minSdkVersion
        targetSdkVersion project.ext.targetSdkVersion
        versionCode project.ext.releaseVersionCode
        versionName project.ext.releaseVersion
        setProperty("archivesBaseName", "teleportage-$versionName")
        multiDexEnabled true
    }
    dokka {
        outputFormat = 'html'
        outputDirectory = "$buildDir/dokka"

        configuration …

我正在将使用 Apollo Client 的应用程序从 v2 升级到 v3，但找不到以下问题的正确解决方案。

我有一个产品的架构，在这个产品中，有一个价格。这个价格不是一个简单的数字，因为它包含免税价值、所有税金包括价值和增值税。

type Product {
   id: ID
   price: Price
}

type Price {
   dutyFree: Float
   allTaxesIncluded: Float
   VAT: Float
}

在 Apollo Client 2 中，只要没有明确的 id 或 _id 属性，InMemoryCache 就会根据对象的路径创建回退假标识符来规范数据。

在 Apollo Client 3 中，不再生成此后备假标识符。相反，您有两种选择来处理非规范化数据。第一个是使用新的 TypePolicy 选项并明确指示您收到的数据不应标准化。在这种情况下，数据将链接到父规范化数据。

文档：

未规范化的对象会嵌入到缓存中的父对象中。您不能直接访问这些对象，但可以通过它们的父对象访问它们。

new InMemoryCache({
   typePolicies: {
      Price {
         keyFields: false
      }
   }
})

都很开心，虽然我的问题解决了。好吧，错了......我可以在我的应用程序中创建一个产品并添加一个价格。但是，每当我更改现有价格时，都会收到以下警告：

替换 Product 对象的 price 字段时，缓存数据可能会丢失。

因为，当我在更新后获取我的 Product 时，InMemoryCache 不知道如何合并字段 Price 因为没有定义 id，这是非规范化数据的点。

我知道有第二个选项可以为我的 Product.price 字段显式定义合并函数，但这个例子是现实的一个更简单的版本。我通过多个类型为 Price 的对象有大量字段，并且为每个对象手动定义一个合并函数（即使通过外部化函数中的公共逻辑）是我发现效率非常低和错误的来源。

所以我的问题是：我对这个keyFields: false选项有什么误解，我可以做些什么来解决这个问题，而不必求助于在我的应用程序中为 50 多个字段定义合并函数？ …