_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q32300 | ByCustomPrefix | train | func ByCustomPrefix(objType, index, value string) By {
return byCustomPrefix{
objType: objType,
index: index,
value: value,
}
} | go | {
"resource": ""
} |
q32301 | DefaultConfig | train | func DefaultConfig() *Config {
return &Config{
ClusterName: store.DefaultClusterName,
Keylen: DefaultKeyLen,
RotationInterval: DefaultKeyRotationInterval,
Subsystems: []string{SubsystemGossip, SubsystemIPSec},
}
} | go | {
"resource": ""
} |
q32302 | New | train | func New(store *store.MemoryStore, config *Config) *KeyManager {
for _, subsys := range config.Subsystems {
if subsys != SubsystemGossip && subsys != SubsystemIPSec {
return nil
}
}
return &KeyManager{
config: config,
store: store,
keyRing: &keyRing{lClock: genSkew()},
}
} | go | {
"resource": ""
} |
q32303 | Run | train | func (k *KeyManager) Run(ctx context.Context) error {
k.mu.Lock()
ctx = log.WithModule(ctx, "keymanager")
var (
clusters []*api.Cluster
err error
)
k.store.View(func(readTx store.ReadTx) {
clusters, err = store.FindClusters(readTx, store.ByName(k.config.ClusterName))
})
if err != nil {
log.G(ctx).E... | go | {
"resource": ""
} |
q32304 | Stop | train | func (k *KeyManager) Stop() error {
k.mu.Lock()
defer k.mu.Unlock()
if k.cancel == nil {
return errors.New("keymanager is not started")
}
k.cancel()
return nil
} | go | {
"resource": ""
} |
q32305 | genSkew | train | func genSkew() uint64 {
b := make([]byte, 2)
if _, err := cryptorand.Read(b); err != nil {
panic(err)
}
return uint64(binary.BigEndian.Uint16(b))
} | go | {
"resource": ""
} |
q32306 | Signer | train | func (rca *RootCA) Signer() (*LocalSigner, error) {
if rca.Pool == nil || rca.signer == nil || len(rca.signer.Cert) == 0 || rca.signer.Signer == nil {
return nil, ErrNoValidSigner
}
return rca.signer, nil
} | go | {
"resource": ""
} |
q32307 | IssueAndSaveNewCertificates | train | func (rca *RootCA) IssueAndSaveNewCertificates(kw KeyWriter, cn, ou, org string) (*tls.Certificate, *IssuerInfo, error) {
csr, key, err := GenerateNewCSR()
if err != nil {
return nil, nil, errors.Wrap(err, "error when generating new node certs")
}
// Obtain a signed Certificate
certChain, err := rca.ParseValida... | go | {
"resource": ""
} |
q32308 | RequestAndSaveNewCertificates | train | func (rca *RootCA) RequestAndSaveNewCertificates(ctx context.Context, kw KeyWriter, config CertificateRequestConfig) (*tls.Certificate, *IssuerInfo, error) {
// Create a new key/pair and CSR
csr, key, err := GenerateNewCSR()
if err != nil {
return nil, nil, errors.Wrap(err, "error when generating new node certs")
... | go | {
"resource": ""
} |
q32309 | PrepareCSR | train | func PrepareCSR(csrBytes []byte, cn, ou, org string) cfsigner.SignRequest {
// All managers get added the subject-alt-name of CA, so they can be
// used for cert issuance.
hosts := []string{ou, cn}
if ou == ManagerRole {
hosts = append(hosts, CARole)
}
return cfsigner.SignRequest{
Request: string(csrBytes),
... | go | {
"resource": ""
} |
q32310 | ParseValidateAndSignCSR | train | func (rca *RootCA) ParseValidateAndSignCSR(csrBytes []byte, cn, ou, org string) ([]byte, error) {
signRequest := PrepareCSR(csrBytes, cn, ou, org)
signer, err := rca.Signer()
if err != nil {
return nil, err
}
cert, err := signer.Sign(signRequest)
if err != nil {
return nil, errors.Wrap(err, "failed to sign no... | go | {
"resource": ""
} |
q32311 | CrossSignCACertificate | train | func (rca *RootCA) CrossSignCACertificate(otherCAPEM []byte) ([]byte, error) {
signer, err := rca.Signer()
if err != nil {
return nil, err
}
// create a new cert with exactly the same parameters, including the public key and exact NotBefore and NotAfter
template, err := helpers.ParseCertificatePEM(otherCAPEM)
... | go | {
"resource": ""
} |
q32312 | NewRootCA | train | func NewRootCA(rootCertBytes, signCertBytes, signKeyBytes []byte, certExpiry time.Duration, intermediates []byte) (RootCA, error) {
// Parse all the certificates in the cert bundle
parsedCerts, err := helpers.ParseCertificatesPEM(rootCertBytes)
if err != nil {
return RootCA{}, errors.Wrap(err, "invalid root certif... | go | {
"resource": ""
} |
q32313 | newLocalSigner | train | func newLocalSigner(keyBytes, certBytes []byte, certExpiry time.Duration, rootPool, intermediatePool *x509.CertPool) (*LocalSigner, error) {
if len(keyBytes) == 0 || len(certBytes) == 0 {
return nil, errors.New("must provide both a signing key and a signing cert, or neither")
}
parsedCerts, err := helpers.ParseCe... | go | {
"resource": ""
} |
q32314 | GetLocalRootCA | train | func GetLocalRootCA(paths CertPaths) (RootCA, error) {
// Check if we have a Certificate file
cert, err := ioutil.ReadFile(paths.Cert)
if err != nil {
if os.IsNotExist(err) {
err = ErrNoLocalRootCA
}
return RootCA{}, err
}
signingCert := cert
key, err := ioutil.ReadFile(paths.Key)
if err != nil {
if... | go | {
"resource": ""
} |
q32315 | GetRemoteCA | train | func GetRemoteCA(ctx context.Context, d digest.Digest, connBroker *connectionbroker.Broker) (RootCA, error) {
// This TLS Config is intentionally using InsecureSkipVerify. We use the
// digest instead to check the integrity of the CA certificate.
insecureCreds := credentials.NewTLS(&tls.Config{InsecureSkipVerify: tr... | go | {
"resource": ""
} |
q32316 | CreateRootCA | train | func CreateRootCA(rootCN string) (RootCA, error) {
// Create a simple CSR for the CA using the default CA validator and policy
req := cfcsr.CertificateRequest{
CN: rootCN,
KeyRequest: &cfcsr.BasicKeyRequest{A: RootKeyAlgo, S: RootKeySize},
CA: &cfcsr.CAConfig{Expiry: RootCAExpiration},
}
// G... | go | {
"resource": ""
} |
q32317 | readCertValidity | train | func readCertValidity(kr KeyReader) (time.Time, time.Time, error) {
var zeroTime time.Time
// Read the Cert
cert, _, err := kr.Read()
if err != nil {
return zeroTime, zeroTime, err
}
// Create an x509 certificate out of the contents on disk
certBlock, _ := pem.Decode(cert)
if certBlock == nil {
return zero... | go | {
"resource": ""
} |
q32318 | SaveRootCA | train | func SaveRootCA(rootCA RootCA, paths CertPaths) error {
// Make sure the necessary dirs exist and they are writable
err := os.MkdirAll(filepath.Dir(paths.Cert), 0755)
if err != nil {
return err
}
// If the root certificate got returned successfully, save the rootCA to disk.
return ioutils.AtomicWriteFile(paths... | go | {
"resource": ""
} |
q32319 | GenerateNewCSR | train | func GenerateNewCSR() ([]byte, []byte, error) {
req := &cfcsr.CertificateRequest{
KeyRequest: cfcsr.NewBasicKeyRequest(),
}
csr, key, err := cfcsr.ParseRequest(req)
if err != nil {
return nil, nil, err
}
key, err = pkcs8.ConvertECPrivateKeyPEM(key)
return csr, key, err
} | go | {
"resource": ""
} |
q32320 | NormalizePEMs | train | func NormalizePEMs(certs []byte) []byte {
var (
results []byte
pemBlock *pem.Block
)
for {
pemBlock, certs = pem.Decode(bytes.TrimSpace(certs))
if pemBlock == nil {
return results
}
pemBlock.Headers = nil
results = append(results, pem.EncodeToMemory(pemBlock)...)
}
} | go | {
"resource": ""
} |
q32321 | Matches | train | func (e EventCommit) Matches(watchEvent events.Event) bool {
_, ok := watchEvent.(EventCommit)
return ok
} | go | {
"resource": ""
} |
q32322 | TaskCheckStateGreaterThan | train | func TaskCheckStateGreaterThan(t1, t2 *api.Task) bool {
return t2.Status.State > t1.Status.State
} | go | {
"resource": ""
} |
q32323 | NodeCheckState | train | func NodeCheckState(n1, n2 *api.Node) bool {
return n1.Status.State == n2.Status.State
} | go | {
"resource": ""
} |
q32324 | Matcher | train | func Matcher(specifiers ...api.Event) events.MatcherFunc {
return events.MatcherFunc(func(event events.Event) bool {
for _, s := range specifiers {
if s.Matches(event) {
return true
}
}
return false
})
} | go | {
"resource": ""
} |
q32325 | CreateResource | train | func (s *Server) CreateResource(ctx context.Context, request *api.CreateResourceRequest) (*api.CreateResourceResponse, error) {
if request.Annotations == nil || request.Annotations.Name == "" {
return nil, status.Errorf(codes.InvalidArgument, "Resource must have a name")
}
// finally, validate that Kind is not an... | go | {
"resource": ""
} |
q32326 | GetResource | train | func (s *Server) GetResource(ctx context.Context, request *api.GetResourceRequest) (*api.GetResourceResponse, error) {
if request.ResourceID == "" {
return nil, status.Errorf(codes.InvalidArgument, "resource ID must be present")
}
var resource *api.Resource
s.store.View(func(tx store.ReadTx) {
resource = store.... | go | {
"resource": ""
} |
q32327 | RemoveResource | train | func (s *Server) RemoveResource(ctx context.Context, request *api.RemoveResourceRequest) (*api.RemoveResourceResponse, error) {
if request.ResourceID == "" {
return nil, status.Errorf(codes.InvalidArgument, "resource ID must be present")
}
err := s.store.Update(func(tx store.Tx) error {
return store.DeleteResour... | go | {
"resource": ""
} |
q32328 | ListResources | train | func (s *Server) ListResources(ctx context.Context, request *api.ListResourcesRequest) (*api.ListResourcesResponse, error) {
var (
resources []*api.Resource
respResources []*api.Resource
err error
byFilters []store.By
by store.By
labels map[string]string
)
// andKind ... | go | {
"resource": ""
} |
q32329 | UpdateResource | train | func (s *Server) UpdateResource(ctx context.Context, request *api.UpdateResourceRequest) (*api.UpdateResourceResponse, error) {
if request.ResourceID == "" || request.ResourceVersion == nil {
return nil, status.Errorf(codes.InvalidArgument, "must include ID and version")
}
var r *api.Resource
err := s.store.Updat... | go | {
"resource": ""
} |
q32330 | Get | train | func (r *configs) Get(configID string) (*api.Config, error) {
r.mu.RLock()
defer r.mu.RUnlock()
if r, ok := r.m[configID]; ok {
return r, nil
}
return nil, fmt.Errorf("config %s not found", configID)
} | go | {
"resource": ""
} |
q32331 | Add | train | func (r *configs) Add(configs ...api.Config) {
r.mu.Lock()
defer r.mu.Unlock()
for _, config := range configs {
r.m[config.ID] = config.Copy()
}
} | go | {
"resource": ""
} |
q32332 | Remove | train | func (r *configs) Remove(configs []string) {
r.mu.Lock()
defer r.mu.Unlock()
for _, config := range configs {
delete(r.m, config)
}
} | go | {
"resource": ""
} |
q32333 | Reset | train | func (r *configs) Reset() {
r.mu.Lock()
defer r.mu.Unlock()
r.m = make(map[string]*api.Config)
} | go | {
"resource": ""
} |
q32334 | Restrict | train | func Restrict(configs exec.ConfigGetter, t *api.Task) exec.ConfigGetter {
cids := map[string]struct{}{}
container := t.Spec.GetContainer()
if container != nil {
for _, configRef := range container.Configs {
cids[configRef.ConfigID] = struct{}{}
}
}
return &taskRestrictedConfigsProvider{configs: configs, c... | go | {
"resource": ""
} |
q32335 | NewServer | train | func NewServer(store *store.MemoryStore, raft *raft.Node, securityConfig *ca.SecurityConfig, pg plugingetter.PluginGetter, dr *drivers.DriverProvider) *Server {
return &Server{
store: store,
dr: dr,
raft: raft,
securityConfig: securityConfig,
pg: pg,
}
} | go | {
"resource": ""
} |
q32336 | BindControl | train | func (m *Manager) BindControl(addr string) error {
m.addrMu.Lock()
defer m.addrMu.Unlock()
if m.config.ControlAPI != "" {
return errors.New("manager already has a control API address")
}
// don't create a socket directory if we're on windows. we used named pipe
if runtime.GOOS != "windows" {
err := os.Mkdir... | go | {
"resource": ""
} |
q32337 | BindRemote | train | func (m *Manager) BindRemote(ctx context.Context, addrs RemoteAddrs) error {
m.addrMu.Lock()
defer m.addrMu.Unlock()
if m.config.RemoteAPI != nil {
return errors.New("manager already has remote API address")
}
// If an AdvertiseAddr was specified, we use that as our
// externally-reachable address.
advertise... | go | {
"resource": ""
} |
q32338 | Addr | train | func (m *Manager) Addr() string {
m.addrMu.Lock()
defer m.addrMu.Unlock()
if m.config.RemoteAPI == nil {
return ""
}
return m.config.RemoteAPI.ListenAddr
} | go | {
"resource": ""
} |
q32339 | Stop | train | func (m *Manager) Stop(ctx context.Context, clearData bool) {
log.G(ctx).Info("Stopping manager")
// It's not safe to start shutting down while the manager is still
// starting up.
<-m.started
// the mutex stops us from trying to stop while we're already stopping, or
// from returning before we've finished stopp... | go | {
"resource": ""
} |
q32340 | handleLeadershipEvents | train | func (m *Manager) handleLeadershipEvents(ctx context.Context, leadershipCh chan events.Event) {
// get the current leader and save it for logging leadership changes in
// this loop
oldLeader := m.getLeaderNodeID()
for {
select {
case leadershipEvent := <-leadershipCh:
m.mu.Lock()
if m.stopped {
m.mu.U... | go | {
"resource": ""
} |
q32341 | serveListener | train | func (m *Manager) serveListener(ctx context.Context, lCh <-chan net.Listener) {
var l net.Listener
select {
case l = <-lCh:
case <-ctx.Done():
return
}
ctx = log.WithLogger(ctx, log.G(ctx).WithFields(
logrus.Fields{
"proto": l.Addr().Network(),
"addr": l.Addr().String(),
}))
if _, ok := l.(*net.TCPL... | go | {
"resource": ""
} |
q32342 | becomeFollower | train | func (m *Manager) becomeFollower() {
// The following components are gRPC services that are
// registered when creating the manager and will need
// to be re-registered if they are recreated.
// For simplicity, they are not nilled out.
m.dispatcher.Stop()
m.logbroker.Stop()
m.caserver.Stop()
if m.allocator != ... | go | {
"resource": ""
} |
q32343 | defaultClusterObject | train | func defaultClusterObject(
clusterID string,
initialCAConfig api.CAConfig,
raftCfg api.RaftConfig,
encryptionConfig api.EncryptionConfig,
initialUnlockKeys []*api.EncryptionKey,
rootCA *ca.RootCA,
fips bool,
defaultAddressPool []string,
subnetSize uint32,
vxlanUDPPort uint32) *api.Cluster {
var caKey []byte
... | go | {
"resource": ""
} |
q32344 | managerNode | train | func managerNode(nodeID string, availability api.NodeSpec_Availability, vxlanPort uint32) *api.Node {
return &api.Node{
ID: nodeID,
Certificate: api.Certificate{
CN: nodeID,
Role: api.NodeRoleManager,
Status: api.IssuanceStatus{
State: api.IssuanceStateIssued,
},
},
Spec: api.NodeSpec{
Des... | go | {
"resource": ""
} |
q32345 | newIngressNetwork | train | func newIngressNetwork() *api.Network {
return &api.Network{
ID: identity.NewID(),
Spec: api.NetworkSpec{
Ingress: true,
Annotations: api.Annotations{
Name: "ingress",
},
DriverConfig: &api.Driver{},
IPAM: &api.IPAMOptions{
Driver: &api.Driver{},
Configs: []*api.IPAMConfig{
{
... | go | {
"resource": ""
} |
q32346 | newPredefinedNetwork | train | func newPredefinedNetwork(name, driver string) *api.Network {
return &api.Network{
ID: identity.NewID(),
Spec: api.NetworkSpec{
Annotations: api.Annotations{
Name: name,
Labels: map[string]string{
networkallocator.PredefinedLabel: "true",
},
},
DriverConfig: &api.Driver{Name: driver},
}... | go | {
"resource": ""
} |
q32347 | GetConfig | train | func (s *Server) GetConfig(ctx context.Context, request *api.GetConfigRequest) (*api.GetConfigResponse, error) {
if request.ConfigID == "" {
return nil, status.Errorf(codes.InvalidArgument, "config ID must be provided")
}
var config *api.Config
s.store.View(func(tx store.ReadTx) {
config = store.GetConfig(tx, ... | go | {
"resource": ""
} |
q32348 | UpdateConfig | train | func (s *Server) UpdateConfig(ctx context.Context, request *api.UpdateConfigRequest) (*api.UpdateConfigResponse, error) {
if request.ConfigID == "" || request.ConfigVersion == nil {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var config *api.Config
err := s.store.Update(func(tx... | go | {
"resource": ""
} |
q32349 | ListConfigs | train | func (s *Server) ListConfigs(ctx context.Context, request *api.ListConfigsRequest) (*api.ListConfigsResponse, error) {
var (
configs []*api.Config
respConfigs []*api.Config
err error
byFilters []store.By
by store.By
labels map[string]string
)
// return all configs that match ... | go | {
"resource": ""
} |
q32350 | CreateConfig | train | func (s *Server) CreateConfig(ctx context.Context, request *api.CreateConfigRequest) (*api.CreateConfigResponse, error) {
if err := validateConfigSpec(request.Spec); err != nil {
return nil, err
}
config := configFromConfigSpec(request.Spec) // the store will handle name conflicts
err := s.store.Update(func(tx s... | go | {
"resource": ""
} |
q32351 | RemoveConfig | train | func (s *Server) RemoveConfig(ctx context.Context, request *api.RemoveConfigRequest) (*api.RemoveConfigResponse, error) {
if request.ConfigID == "" {
return nil, status.Errorf(codes.InvalidArgument, "config ID must be provided")
}
err := s.store.Update(func(tx store.Tx) error {
// Check if the config exists
c... | go | {
"resource": ""
} |
q32352 | ListenLocal | train | func ListenLocal(socket string) (net.Listener, error) {
// set up ACL for the named pipe
// allow Administrators and SYSTEM
sddl := "D:P(A;;GA;;;BA)(A;;GA;;;SY)"
c := winio.PipeConfig{
SecurityDescriptor: sddl,
MessageMode: true, // Use message mode so that CloseWrite() is supported
InputBufferSize: ... | go | {
"resource": ""
} |
q32353 | dial | train | func dial(addr string, protocol string, creds credentials.TransportCredentials, timeout time.Duration) (*grpc.ClientConn, error) {
// gRPC dialer connects to proxy first. Provide a custom dialer here avoid that.
grpcOptions := []grpc.DialOption{
grpc.WithBackoffMaxDelay(2 * time.Second),
grpc.WithTransportCredent... | go | {
"resource": ""
} |
q32354 | Register | train | func Register(server *grpc.Server, node *Node) {
api.RegisterRaftServer(server, node)
api.RegisterRaftMembershipServer(server, node)
} | go | {
"resource": ""
} |
q32355 | WaitForLeader | train | func WaitForLeader(ctx context.Context, n *Node) error {
_, err := n.Leader()
if err == nil {
return nil
}
ticker := time.NewTicker(50 * time.Millisecond)
defer ticker.Stop()
for err != nil {
select {
case <-ticker.C:
case <-ctx.Done():
return ctx.Err()
}
_, err = n.Leader()
}
return nil
} | go | {
"resource": ""
} |
q32356 | WaitForCluster | train | func WaitForCluster(ctx context.Context, n *Node) (cluster *api.Cluster, err error) {
watch, cancel := state.Watch(n.MemoryStore().WatchQueue(), api.EventCreateCluster{})
defer cancel()
var clusters []*api.Cluster
n.MemoryStore().View(func(readTx store.ReadTx) {
clusters, err = store.FindClusters(readTx, store.B... | go | {
"resource": ""
} |
q32357 | checkSessionID | train | func (rn *registeredNode) checkSessionID(sessionID string) error {
rn.mu.Lock()
defer rn.mu.Unlock()
// Before each message send, we need to check the nodes sessionID hasn't
// changed. If it has, we will the stream and make the node
// re-register.
if sessionID == "" || rn.SessionID != sessionID {
return stat... | go | {
"resource": ""
} |
q32358 | CheckRateLimit | train | func (s *nodeStore) CheckRateLimit(id string) error {
s.mu.Lock()
defer s.mu.Unlock()
if existRn, ok := s.nodes[id]; ok {
if time.Since(existRn.Registered) > s.rateLimitPeriod {
existRn.Attempts = 0
}
existRn.Attempts++
if existRn.Attempts > rateLimitCount {
return status.Errorf(codes.Unavailable, "nod... | go | {
"resource": ""
} |
q32359 | Add | train | func (s *nodeStore) Add(n *api.Node, expireFunc func()) *registeredNode {
s.mu.Lock()
defer s.mu.Unlock()
var attempts int
var registered time.Time
if existRn, ok := s.nodes[n.ID]; ok {
attempts = existRn.Attempts
registered = existRn.Registered
existRn.Heartbeat.Stop()
delete(s.nodes, n.ID)
}
if registe... | go | {
"resource": ""
} |
q32360 | Clean | train | func (s *nodeStore) Clean() {
s.mu.Lock()
for _, rn := range s.nodes {
rn.Heartbeat.Stop()
}
s.nodes = make(map[string]*registeredNode)
s.mu.Unlock()
} | go | {
"resource": ""
} |
q32361 | Controller | train | func (e *executor) Controller(t *api.Task) (exec.Controller, error) {
// Get the node description from the executor field
e.mutex.Lock()
nodeDescription := e.node
e.mutex.Unlock()
ctlr, err := newController(e.client, nodeDescription, t, secrets.Restrict(e.secrets, t))
if err != nil {
return nil, err
}
return... | go | {
"resource": ""
} |
q32362 | NewLimitQueue | train | func NewLimitQueue(dst events.Sink, limit uint64) *LimitQueue {
eq := LimitQueue{
dst: dst,
events: list.New(),
limit: limit,
full: make(chan struct{}),
}
eq.cond = sync.NewCond(&eq.mu)
go eq.run()
return &eq
} | go | {
"resource": ""
} |
q32363 | Write | train | func (eq *LimitQueue) Write(event events.Event) error {
eq.mu.Lock()
defer eq.mu.Unlock()
if eq.closed {
return events.ErrSinkClosed
}
if eq.limit > 0 && uint64(eq.events.Len()) >= eq.limit {
// If the limit has been reached, don't write the event to the queue,
// and close the Full channel. This notifies ... | go | {
"resource": ""
} |
q32364 | Len | train | func (eq *LimitQueue) Len() int {
eq.mu.Lock()
defer eq.mu.Unlock()
return eq.events.Len()
} | go | {
"resource": ""
} |
q32365 | IssuerFromAPIRootCA | train | func IssuerFromAPIRootCA(rootCA *api.RootCA) (*IssuerInfo, error) {
wantedIssuer := rootCA.CACert
if rootCA.RootRotation != nil {
wantedIssuer = rootCA.RootRotation.CACert
}
issuerCerts, err := helpers.ParseCertificatesPEM(wantedIssuer)
if err != nil {
return nil, errors.Wrap(err, "invalid certificate in clust... | go | {
"resource": ""
} |
q32366 | finishRootRotation | train | func (r *rootRotationReconciler) finishRootRotation(tx store.Tx, expectedRootCA *api.RootCA) error {
cluster := store.GetCluster(tx, r.clusterID)
if cluster == nil {
return fmt.Errorf("unable to get cluster %s", r.clusterID)
}
// If the RootCA object has changed (because another root rotation was started or beca... | go | {
"resource": ""
} |
q32367 | NewDependencyManager | train | func NewDependencyManager() exec.DependencyManager {
return &dependencyManager{
secrets: secrets.NewManager(),
configs: configs.NewManager(),
}
} | go | {
"resource": ""
} |
q32368 | Restrict | train | func Restrict(dependencies exec.DependencyManager, t *api.Task) exec.DependencyGetter {
return &dependencyGetter{
secrets: secrets.Restrict(dependencies.Secrets(), t),
configs: configs.Restrict(dependencies.Configs(), t),
}
} | go | {
"resource": ""
} |
q32369 | New | train | func New(store *store.MemoryStore) *Scheduler {
return &Scheduler{
store: store,
unassignedTasks: make(map[string]*api.Task),
pendingPreassignedTasks: make(map[string]*api.Task),
preassignedTasks: make(map[string]struct{}),
allTasks: make(map[string]*api.Task),... | go | {
"resource": ""
} |
q32370 | Run | train | func (s *Scheduler) Run(ctx context.Context) error {
defer close(s.doneChan)
updates, cancel, err := store.ViewAndWatch(s.store, s.setupTasksList)
if err != nil {
log.G(ctx).WithError(err).Errorf("snapshot store update failed")
return err
}
defer cancel()
// Validate resource for tasks from preassigned task... | go | {
"resource": ""
} |
q32371 | enqueue | train | func (s *Scheduler) enqueue(t *api.Task) {
s.unassignedTasks[t.ID] = t
} | go | {
"resource": ""
} |
q32372 | tick | train | func (s *Scheduler) tick(ctx context.Context) {
type commonSpecKey struct {
serviceID string
specVersion api.Version
}
tasksByCommonSpec := make(map[commonSpecKey]map[string]*api.Task)
var oneOffTasks []*api.Task
schedulingDecisions := make(map[string]schedulingDecision, len(s.unassignedTasks))
for taskID,... | go | {
"resource": ""
} |
q32373 | taskFitNode | train | func (s *Scheduler) taskFitNode(ctx context.Context, t *api.Task, nodeID string) *api.Task {
nodeInfo, err := s.nodeSet.nodeInfo(nodeID)
if err != nil {
// node does not exist in set (it may have been deleted)
return nil
}
newT := *t
s.pipeline.SetTask(t)
if !s.pipeline.Process(&nodeInfo) {
// this node can... | go | {
"resource": ""
} |
q32374 | scheduleTaskGroup | train | func (s *Scheduler) scheduleTaskGroup(ctx context.Context, taskGroup map[string]*api.Task, schedulingDecisions map[string]schedulingDecision) {
// Pick at task at random from taskGroup to use for constraint
// evaluation. It doesn't matter which one we pick because all the
// tasks in the group are equal in terms of... | go | {
"resource": ""
} |
q32375 | NewSnapFactory | train | func NewSnapFactory(encrypter encryption.Encrypter, decrypter encryption.Decrypter) SnapFactory {
return snapCryptor{
encrypter: encrypter,
decrypter: decrypter,
}
} | go | {
"resource": ""
} |
q32376 | New | train | func (sc snapCryptor) New(dirpath string) Snapshotter {
return &wrappedSnap{
Snapshotter: snap.New(dirpath),
encrypter: sc.encrypter,
decrypter: sc.decrypter,
}
} | go | {
"resource": ""
} |
q32377 | MigrateSnapshot | train | func MigrateSnapshot(oldDir, newDir string, oldFactory, newFactory SnapFactory) error {
// use temporary snapshot directory so initialization appears atomic
oldSnapshotter := oldFactory.New(oldDir)
snapshot, err := oldSnapshotter.Load()
switch err {
case snap.ErrNoSnapshot: // if there's no snapshot, the migration... | go | {
"resource": ""
} |
q32378 | handleTaskChange | train | func (r *Orchestrator) handleTaskChange(ctx context.Context, t *api.Task) {
// If we already set the desired state past TaskStateRunning, there is no
// further action necessary.
if t.DesiredState > api.TaskStateRunning {
return
}
var (
n *api.Node
service *api.Service
)
r.store.View(func(tx store.R... | go | {
"resource": ""
} |
q32379 | FixTask | train | func (r *Orchestrator) FixTask(ctx context.Context, batch *store.Batch, t *api.Task) {
// If we already set the desired state past TaskStateRunning, there is no
// further action necessary.
if t.DesiredState > api.TaskStateRunning {
return
}
var (
n *api.Node
service *api.Service
)
batch.Update(func... | go | {
"resource": ""
} |
q32380 | newRootRotationObject | train | func newRootRotationObject(ctx context.Context, securityConfig *ca.SecurityConfig, apiRootCA *api.RootCA, newCARootCA ca.RootCA, extCAs []*api.ExternalCA, version uint64) (*api.RootCA, error) {
var (
rootCert, rootKey, crossSignedCert []byte
newRootHasSigner bool
err ... | go | {
"resource": ""
} |
q32381 | validateExternalCAURL | train | func validateExternalCAURL(dialer *net.Dialer, tlsOpts *tls.Config, caURL string) error {
parsed, err := url.Parse(caURL)
if err != nil {
return err
}
if parsed.Scheme != "https" {
return errors.New("invalid HTTP scheme")
}
host, port, err := net.SplitHostPort(parsed.Host)
if err != nil {
// It either has ... | go | {
"resource": ""
} |
q32382 | validateHasAtLeastOneExternalCA | train | func validateHasAtLeastOneExternalCA(ctx context.Context, externalCAs map[string][]*api.ExternalCA, securityConfig *ca.SecurityConfig,
wantedCert []byte, desc string) ([]*api.ExternalCA, error) {
specific, ok := externalCAs[string(wantedCert)]
if ok {
pool := x509.NewCertPool()
pool.AppendCertsFromPEM(wantedCert... | go | {
"resource": ""
} |
q32383 | Stop | train | func (c *testCluster) Stop() error {
c.cancel()
for _, n := range c.nodes {
if err := n.Stop(); err != nil {
return err
}
}
c.wg.Wait()
close(c.errs)
for err := range c.errs {
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q32384 | RandomManager | train | func (c *testCluster) RandomManager() *testNode {
var managers []*testNode
for _, n := range c.nodes {
if n.IsManager() {
managers = append(managers, n)
}
}
idx := rand.Intn(len(managers))
return managers[idx]
} | go | {
"resource": ""
} |
q32385 | AddManager | train | func (c *testCluster) AddManager(lateBind bool, rootCA *ca.RootCA) error {
// first node
var n *testNode
if len(c.nodes) == 0 {
node, err := newTestNode("", "", lateBind, c.fips)
if err != nil {
return err
}
// generate TLS certs for this manager for bootstrapping, else the node will generate its own CA
... | go | {
"resource": ""
} |
q32386 | AddNode | train | func (c *testCluster) AddNode(n *testNode) error {
c.counter++
if err := c.runNode(n, c.counter); err != nil {
c.counter--
return err
}
c.nodes[n.node.NodeID()] = n
c.nodesOrder[n.node.NodeID()] = c.counter
return nil
} | go | {
"resource": ""
} |
q32387 | CreateService | train | func (c *testCluster) CreateService(name string, instances int) (string, error) {
spec := &api.ServiceSpec{
Annotations: api.Annotations{Name: name},
Mode: &api.ServiceSpec_Replicated{
Replicated: &api.ReplicatedService{
Replicas: uint64(instances),
},
},
Task: api.TaskSpec{
Runtime: &api.TaskSpec... | go | {
"resource": ""
} |
q32388 | Leader | train | func (c *testCluster) Leader() (*testNode, error) {
resp, err := c.api.ListNodes(context.Background(), &api.ListNodesRequest{
Filters: &api.ListNodesRequest_Filters{
Roles: []api.NodeRole{api.NodeRoleManager},
},
})
if err != nil {
return nil, err
}
for _, n := range resp.Nodes {
if n.ManagerStatus.Lead... | go | {
"resource": ""
} |
q32389 | RemoveNode | train | func (c *testCluster) RemoveNode(id string, graceful bool) error {
node, ok := c.nodes[id]
if !ok {
return fmt.Errorf("remove node: node %s not found", id)
}
// demote before removal
if node.IsManager() {
if err := c.SetNodeRole(id, api.NodeRoleWorker); err != nil {
return fmt.Errorf("demote manager: %v", e... | go | {
"resource": ""
} |
q32390 | SetNodeRole | train | func (c *testCluster) SetNodeRole(id string, role api.NodeRole) error {
node, ok := c.nodes[id]
if !ok {
return fmt.Errorf("set node role: node %s not found", id)
}
if node.IsManager() && role == api.NodeRoleManager {
return fmt.Errorf("node is already manager")
}
if !node.IsManager() && role == api.NodeRoleW... | go | {
"resource": ""
} |
q32391 | StartNode | train | func (c *testCluster) StartNode(id string) error {
n, ok := c.nodes[id]
if !ok {
return fmt.Errorf("set node role: node %s not found", id)
}
if err := c.runNode(n, c.nodesOrder[id]); err != nil {
return err
}
if n.node.NodeID() != id {
return fmt.Errorf("restarted node does not have have the same ID")
}
r... | go | {
"resource": ""
} |
q32392 | GetSecret | train | func (s *Server) GetSecret(ctx context.Context, request *api.GetSecretRequest) (*api.GetSecretResponse, error) {
if request.SecretID == "" {
return nil, status.Errorf(codes.InvalidArgument, "secret ID must be provided")
}
var secret *api.Secret
s.store.View(func(tx store.ReadTx) {
secret = store.GetSecret(tx, ... | go | {
"resource": ""
} |
q32393 | UpdateSecret | train | func (s *Server) UpdateSecret(ctx context.Context, request *api.UpdateSecretRequest) (*api.UpdateSecretResponse, error) {
if request.SecretID == "" || request.SecretVersion == nil {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var secret *api.Secret
err := s.store.Update(func(tx ... | go | {
"resource": ""
} |
q32394 | ListSecrets | train | func (s *Server) ListSecrets(ctx context.Context, request *api.ListSecretsRequest) (*api.ListSecretsResponse, error) {
var (
secrets []*api.Secret
respSecrets []*api.Secret
err error
byFilters []store.By
by store.By
labels map[string]string
)
// return all secrets that match ... | go | {
"resource": ""
} |
q32395 | CreateSecret | train | func (s *Server) CreateSecret(ctx context.Context, request *api.CreateSecretRequest) (*api.CreateSecretResponse, error) {
if err := validateSecretSpec(request.Spec); err != nil {
return nil, err
}
if request.Spec.Driver != nil { // Check that the requested driver is valid
if _, err := s.dr.NewSecretDriver(reque... | go | {
"resource": ""
} |
q32396 | RemoveSecret | train | func (s *Server) RemoveSecret(ctx context.Context, request *api.RemoveSecretRequest) (*api.RemoveSecretResponse, error) {
if request.SecretID == "" {
return nil, status.Errorf(codes.InvalidArgument, "secret ID must be provided")
}
err := s.store.Update(func(tx store.Tx) error {
// Check if the secret exists
s... | go | {
"resource": ""
} |
q32397 | GetCluster | train | func (s *Server) GetCluster(ctx context.Context, request *api.GetClusterRequest) (*api.GetClusterResponse, error) {
if request.ClusterID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var cluster *api.Cluster
s.store.View(func(tx store.ReadTx) {
cluster = store.GetCluste... | go | {
"resource": ""
} |
q32398 | ListClusters | train | func (s *Server) ListClusters(ctx context.Context, request *api.ListClustersRequest) (*api.ListClustersResponse, error) {
var (
clusters []*api.Cluster
err error
)
s.store.View(func(tx store.ReadTx) {
switch {
case request.Filters != nil && len(request.Filters.Names) > 0:
clusters, err = store.FindCl... | go | {
"resource": ""
} |
q32399 | redactClusters | train | func redactClusters(clusters []*api.Cluster) []*api.Cluster {
var redactedClusters []*api.Cluster
// Only add public fields to the new clusters
for _, cluster := range clusters {
// Copy all the mandatory fields
// Do not copy secret keys
redactedSpec := cluster.Spec.Copy()
redactedSpec.CAConfig.SigningCAKey... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.