_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q5800
|
IDs
|
train
|
func (l DocumentMetaSlice) IDs() []DocumentID {
ids := make([]DocumentID, len(l))
for i, m := range l {
ids[i] = m.ID
}
return ids
}
|
go
|
{
"resource": ""
}
|
q5801
|
Version
|
train
|
func (c *client) Version(ctx context.Context) (VersionInfo, error) {
req, err := c.conn.NewRequest("GET", "_api/version")
if err != nil {
return VersionInfo{}, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return VersionInfo{}, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return VersionInfo{}, WithStack(err)
}
var data VersionInfo
if err := resp.ParseBody("", &data); err != nil {
return VersionInfo{}, WithStack(err)
}
return data, nil
}
|
go
|
{
"resource": ""
}
|
q5802
|
asServerRole
|
train
|
func (r roleResponse) asServerRole(ctx context.Context, c *client) (ServerRole, error) {
switch r.Role {
case "SINGLE":
switch r.Mode {
case "resilient":
if err := c.echo(ctx); IsNoLeader(err) {
return ServerRoleSinglePassive, nil
} else if err != nil {
return ServerRoleUndefined, WithStack(err)
}
return ServerRoleSingleActive, nil
default:
return ServerRoleSingle, nil
}
case "PRIMARY":
return ServerRoleDBServer, nil
case "COORDINATOR":
return ServerRoleCoordinator, nil
case "AGENT":
return ServerRoleAgent, nil
case "UNDEFINED":
return ServerRoleUndefined, nil
default:
return ServerRoleUndefined, nil
}
}
|
go
|
{
"resource": ""
}
|
q5803
|
ServerRole
|
train
|
func (c *client) ServerRole(ctx context.Context) (ServerRole, error) {
req, err := c.conn.NewRequest("GET", "_admin/server/role")
if err != nil {
return ServerRoleUndefined, WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return ServerRoleUndefined, WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return ServerRoleUndefined, WithStack(err)
}
var data roleResponse
if err := resp.ParseBody("", &data); err != nil {
return ServerRoleUndefined, WithStack(err)
}
role, err := data.asServerRole(ctx, c)
if err != nil {
return ServerRoleUndefined, WithStack(err)
}
return role, nil
}
|
go
|
{
"resource": ""
}
|
q5804
|
ServerID
|
train
|
func (c *client) ServerID(ctx context.Context) (string, error) {
req, err := c.conn.NewRequest("GET", "_admin/server/id")
if err != nil {
return "", WithStack(err)
}
applyContextSettings(ctx, req)
resp, err := c.conn.Do(ctx, req)
if err != nil {
return "", WithStack(err)
}
if err := resp.CheckStatus(200); err != nil {
return "", WithStack(err)
}
var data idResponse
if err := resp.ParseBody("", &data); err != nil {
return "", WithStack(err)
}
return data.ID, nil
}
|
go
|
{
"resource": ""
}
|
q5805
|
Validate
|
train
|
func (id DocumentID) Validate() error {
if id == "" {
return WithStack(fmt.Errorf("DocumentID is empty"))
}
parts := strings.Split(string(id), "/")
if len(parts) != 2 {
return WithStack(fmt.Errorf("Expected 'collection/key', got '%s'", string(id)))
}
if parts[0] == "" {
return WithStack(fmt.Errorf("Collection part of '%s' is empty", string(id)))
}
if parts[1] == "" {
return WithStack(fmt.Errorf("Key part of '%s' is empty", string(id)))
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5806
|
ValidateOrEmpty
|
train
|
func (id DocumentID) ValidateOrEmpty() error {
if id == "" {
return nil
}
if err := id.Validate(); err != nil {
return WithStack(err)
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5807
|
Collection
|
train
|
func (id DocumentID) Collection() string {
parts := strings.Split(string(id), "/")
return pathUnescape(parts[0])
}
|
go
|
{
"resource": ""
}
|
q5808
|
Key
|
train
|
func (id DocumentID) Key() string {
parts := strings.Split(string(id), "/")
if len(parts) == 2 {
return pathUnescape(parts[1])
}
return ""
}
|
go
|
{
"resource": ""
}
|
q5809
|
NewDocumentID
|
train
|
func NewDocumentID(collection, key string) DocumentID {
return DocumentID(pathEscape(collection) + "/" + pathEscape(key))
}
|
go
|
{
"resource": ""
}
|
q5810
|
WithRevision
|
train
|
func WithRevision(parent context.Context, revision string) context.Context {
return context.WithValue(contextOrBackground(parent), keyRevision, revision)
}
|
go
|
{
"resource": ""
}
|
q5811
|
WithRevisions
|
train
|
func WithRevisions(parent context.Context, revisions []string) context.Context {
return context.WithValue(contextOrBackground(parent), keyRevisions, revisions)
}
|
go
|
{
"resource": ""
}
|
q5812
|
WithReturnNew
|
train
|
func WithReturnNew(parent context.Context, result interface{}) context.Context {
return context.WithValue(contextOrBackground(parent), keyReturnNew, result)
}
|
go
|
{
"resource": ""
}
|
q5813
|
WithReturnOld
|
train
|
func WithReturnOld(parent context.Context, result interface{}) context.Context {
return context.WithValue(contextOrBackground(parent), keyReturnOld, result)
}
|
go
|
{
"resource": ""
}
|
q5814
|
WithEndpoint
|
train
|
func WithEndpoint(parent context.Context, endpoint string) context.Context {
endpoint = util.FixupEndpointURLScheme(endpoint)
return context.WithValue(contextOrBackground(parent), keyEndpoint, endpoint)
}
|
go
|
{
"resource": ""
}
|
q5815
|
WithAllowDirtyReads
|
train
|
func WithAllowDirtyReads(parent context.Context, wasDirtyRead *bool) context.Context {
return context.WithValue(contextOrBackground(parent), keyAllowDirtyReads, wasDirtyRead)
}
|
go
|
{
"resource": ""
}
|
q5816
|
WithRawResponse
|
train
|
func WithRawResponse(parent context.Context, value *[]byte) context.Context {
return context.WithValue(contextOrBackground(parent), keyRawResponse, value)
}
|
go
|
{
"resource": ""
}
|
q5817
|
WithResponse
|
train
|
func WithResponse(parent context.Context, value *Response) context.Context {
return context.WithValue(contextOrBackground(parent), keyResponse, value)
}
|
go
|
{
"resource": ""
}
|
q5818
|
WithImportDetails
|
train
|
func WithImportDetails(parent context.Context, value *[]string) context.Context {
return context.WithValue(contextOrBackground(parent), keyImportDetails, value)
}
|
go
|
{
"resource": ""
}
|
q5819
|
WithIgnoreRevisions
|
train
|
func WithIgnoreRevisions(parent context.Context, value ...bool) context.Context {
v := true
if len(value) == 1 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyIgnoreRevs, v)
}
|
go
|
{
"resource": ""
}
|
q5820
|
WithConfigured
|
train
|
func WithConfigured(parent context.Context, value ...bool) context.Context {
v := true
if len(value) == 1 {
v = value[0]
}
return context.WithValue(contextOrBackground(parent), keyConfigured, v)
}
|
go
|
{
"resource": ""
}
|
q5821
|
WithDBServerID
|
train
|
func WithDBServerID(parent context.Context, id string) context.Context {
return context.WithValue(contextOrBackground(parent), keyDBServerID, id)
}
|
go
|
{
"resource": ""
}
|
q5822
|
WithBatchID
|
train
|
func WithBatchID(parent context.Context, id string) context.Context {
return context.WithValue(contextOrBackground(parent), keyBatchID, id)
}
|
go
|
{
"resource": ""
}
|
q5823
|
WithJobIDResponse
|
train
|
func WithJobIDResponse(parent context.Context, jobID *string) context.Context {
return context.WithValue(contextOrBackground(parent), keyJobIDResponse, jobID)
}
|
go
|
{
"resource": ""
}
|
q5824
|
loadContextResponseValues
|
train
|
func loadContextResponseValues(cs contextSettings, resp Response) {
// Parse potential dirty read
if cs.DirtyReadFlag != nil {
if dirtyRead := resp.Header("X-Arango-Potential-Dirty-Read"); dirtyRead != "" {
*cs.DirtyReadFlag = true // The documentation does not say anything about the actual value (dirtyRead == "true")
} else {
*cs.DirtyReadFlag = false
}
}
}
|
go
|
{
"resource": ""
}
|
q5825
|
setDirtyReadFlagIfRequired
|
train
|
func setDirtyReadFlagIfRequired(ctx context.Context, wasDirty bool) {
if v := ctx.Value(keyAllowDirtyReads); v != nil {
if ref, ok := v.(*bool); ok && ref != nil {
*ref = wasDirty
}
}
}
|
go
|
{
"resource": ""
}
|
q5826
|
Error
|
train
|
func (e KeyNotFoundError) Error() string {
return fmt.Sprintf("Key '%s' not found", strings.Join(e.Key, "/"))
}
|
go
|
{
"resource": ""
}
|
q5827
|
NewPool
|
train
|
func NewPool(numWorkers int, jobQueueLen int) *Pool {
jobQueue := make(chan Job, jobQueueLen)
workerPool := make(chan *worker, numWorkers)
pool := &Pool{
JobQueue: jobQueue,
dispatcher: newDispatcher(workerPool, jobQueue),
}
return pool
}
|
go
|
{
"resource": ""
}
|
q5828
|
OpenQueue
|
train
|
func OpenQueue(dataDir string) (*Queue, error) {
var err error
// Create a new Queue.
q := &Queue{
DataDir: dataDir,
db: &leveldb.DB{},
head: 0,
tail: 0,
isOpen: false,
}
// Open database for the queue.
q.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return q, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goqueQueue)
if err != nil {
return q, err
}
if !ok {
return q, ErrIncompatibleType
}
// Set isOpen and return.
q.isOpen = true
return q, q.init()
}
|
go
|
{
"resource": ""
}
|
q5829
|
Dequeue
|
train
|
func (q *Queue) Dequeue() (*Item, error) {
q.Lock()
defer q.Unlock()
// Check if queue is closed.
if !q.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the queue.
item, err := q.getItemByID(q.head + 1)
if err != nil {
return nil, err
}
// Remove this item from the queue.
if err := q.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
q.head++
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5830
|
Peek
|
train
|
func (q *Queue) Peek() (*Item, error) {
q.RLock()
defer q.RUnlock()
// Check if queue is closed.
if !q.isOpen {
return nil, ErrDBClosed
}
return q.getItemByID(q.head + 1)
}
|
go
|
{
"resource": ""
}
|
q5831
|
Close
|
train
|
func (q *Queue) Close() error {
q.Lock()
defer q.Unlock()
// Check if queue is already closed.
if !q.isOpen {
return nil
}
// Close the LevelDB database.
if err := q.db.Close(); err != nil {
return err
}
// Reset queue head and tail and set
// isOpen to false.
q.head = 0
q.tail = 0
q.isOpen = false
return nil
}
|
go
|
{
"resource": ""
}
|
q5832
|
Drop
|
train
|
func (q *Queue) Drop() error {
if err := q.Close(); err != nil {
return err
}
return os.RemoveAll(q.DataDir)
}
|
go
|
{
"resource": ""
}
|
q5833
|
init
|
train
|
func (q *Queue) init() error {
// Create a new LevelDB Iterator.
iter := q.db.NewIterator(nil, nil)
defer iter.Release()
// Set queue head to the first item.
if iter.First() {
q.head = keyToID(iter.Key()) - 1
}
// Set queue tail to the last item.
if iter.Last() {
q.tail = keyToID(iter.Key())
}
return iter.Error()
}
|
go
|
{
"resource": ""
}
|
q5834
|
checkGoqueType
|
train
|
func checkGoqueType(dataDir string, gt goqueType) (bool, error) {
// Set the path to 'GOQUE' file.
path := filepath.Join(dataDir, "GOQUE")
// Read 'GOQUE' file for this directory.
f, err := os.OpenFile(path, os.O_RDONLY, 0)
if os.IsNotExist(err) {
f, err = os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
if err != nil {
return false, err
}
defer f.Close()
// Create byte slice of goqueType.
gtb := make([]byte, 1)
gtb[0] = byte(gt)
_, err = f.Write(gtb)
if err != nil {
return false, err
}
return true, nil
}
if err != nil {
return false, err
}
defer f.Close()
// Get the saved type from the file.
fb := make([]byte, 1)
_, err = f.Read(fb)
if err != nil {
return false, err
}
// Convert the file byte to its goqueType.
filegt := goqueType(fb[0])
// Compare the types.
if filegt == gt {
return true, nil
} else if filegt == goqueStack && gt == goqueQueue {
return true, nil
} else if filegt == goqueQueue && gt == goqueStack {
return true, nil
}
return false, nil
}
|
go
|
{
"resource": ""
}
|
q5835
|
OpenPrefixQueue
|
train
|
func OpenPrefixQueue(dataDir string) (*PrefixQueue, error) {
var err error
// Create a new Queue.
pq := &PrefixQueue{
DataDir: dataDir,
db: &leveldb.DB{},
isOpen: false,
}
// Open database for the prefix queue.
pq.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return nil, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goquePrefixQueue)
if err != nil {
return nil, err
}
if !ok {
return nil, ErrIncompatibleType
}
// Set isOpen and return.
pq.isOpen = true
return pq, pq.init()
}
|
go
|
{
"resource": ""
}
|
q5836
|
EnqueueString
|
train
|
func (pq *PrefixQueue) EnqueueString(prefix, value string) (*Item, error) {
return pq.Enqueue([]byte(prefix), []byte(value))
}
|
go
|
{
"resource": ""
}
|
q5837
|
Dequeue
|
train
|
func (pq *PrefixQueue) Dequeue(prefix []byte) (*Item, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Try to get the next item in the queue.
item, err := pq.getItemByPrefixID(prefix, q.Head+1)
if err != nil {
return nil, err
}
// Remove this item from the queue.
if err := pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position and decrement prefix queue size.
q.Head++
pq.size--
// Save the queue.
if err := pq.saveQueue(prefix, q); err != nil {
return nil, err
}
// Save main prefix queue data.
if err := pq.save(); err != nil {
return nil, err
}
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5838
|
DequeueString
|
train
|
func (pq *PrefixQueue) DequeueString(prefix string) (*Item, error) {
return pq.Dequeue([]byte(prefix))
}
|
go
|
{
"resource": ""
}
|
q5839
|
Peek
|
train
|
func (pq *PrefixQueue) Peek(prefix []byte) (*Item, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
return pq.getItemByPrefixID(prefix, q.Head+1)
}
|
go
|
{
"resource": ""
}
|
q5840
|
PeekString
|
train
|
func (pq *PrefixQueue) PeekString(prefix string) (*Item, error) {
return pq.Peek([]byte(prefix))
}
|
go
|
{
"resource": ""
}
|
q5841
|
PeekByIDString
|
train
|
func (pq *PrefixQueue) PeekByIDString(prefix string, id uint64) (*Item, error) {
return pq.PeekByID([]byte(prefix), id)
}
|
go
|
{
"resource": ""
}
|
q5842
|
Update
|
train
|
func (pq *PrefixQueue) Update(prefix []byte, id uint64, newValue []byte) (*Item, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Check if item exists in queue.
if id <= q.Head || id > q.Tail {
return nil, ErrOutOfBounds
}
// Create new Item.
item := &Item{
ID: id,
Key: generateKeyPrefixID(prefix, id),
Value: newValue,
}
// Update this item in the queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5843
|
UpdateString
|
train
|
func (pq *PrefixQueue) UpdateString(prefix string, id uint64, value string) (*Item, error) {
return pq.Update([]byte(prefix), id, []byte(value))
}
|
go
|
{
"resource": ""
}
|
q5844
|
Close
|
train
|
func (pq *PrefixQueue) Close() error {
pq.Lock()
defer pq.Unlock()
// Check if queue is already closed.
if !pq.isOpen {
return nil
}
// Close the LevelDB database.
if err := pq.db.Close(); err != nil {
return err
}
// Reset size and set isOpen to false.
pq.size = 0
pq.isOpen = false
return nil
}
|
go
|
{
"resource": ""
}
|
q5845
|
Drop
|
train
|
func (pq *PrefixQueue) Drop() error {
if err := pq.Close(); err != nil {
return err
}
return os.RemoveAll(pq.DataDir)
}
|
go
|
{
"resource": ""
}
|
q5846
|
getQueue
|
train
|
func (pq *PrefixQueue) getQueue(prefix []byte) (*queue, error) {
// Try to get the queue gob value.
qval, err := pq.db.Get(generateKeyPrefixData(prefix), nil)
if err == errors.ErrNotFound {
return nil, ErrEmpty
} else if err != nil {
return nil, err
}
// Decode gob to our queue type.
q := &queue{}
buffer := bytes.NewBuffer(qval)
dec := gob.NewDecoder(buffer)
return q, dec.Decode(q)
}
|
go
|
{
"resource": ""
}
|
q5847
|
saveQueue
|
train
|
func (pq *PrefixQueue) saveQueue(prefix []byte, q *queue) error {
// Encode the queue using gob.
var buffer bytes.Buffer
enc := gob.NewEncoder(&buffer)
if err := enc.Encode(q); err != nil {
return err
}
// Save it to the database.
return pq.db.Put(generateKeyPrefixData(prefix), buffer.Bytes(), nil)
}
|
go
|
{
"resource": ""
}
|
q5848
|
save
|
train
|
func (pq *PrefixQueue) save() error {
val := make([]byte, 8)
binary.BigEndian.PutUint64(val, pq.size)
return pq.db.Put(pq.getDataKey(), val, nil)
}
|
go
|
{
"resource": ""
}
|
q5849
|
getDataKey
|
train
|
func (pq *PrefixQueue) getDataKey() []byte {
var key []byte
key = append(key, prefixDelimiter)
return append(key, []byte(":main_data")...)
}
|
go
|
{
"resource": ""
}
|
q5850
|
getItemByPrefixID
|
train
|
func (pq *PrefixQueue) getItemByPrefixID(prefix []byte, id uint64) (*Item, error) {
// Check if empty.
if pq.size == 0 {
return nil, ErrEmpty
}
// Get the queue for this prefix.
q, err := pq.getQueue(prefix)
if err != nil {
return nil, err
}
// Check if out of bounds.
if id <= q.Head || id > q.Tail {
return nil, ErrOutOfBounds
}
// Get item from database.
item := &Item{
ID: id,
Key: generateKeyPrefixID(prefix, id),
}
if item.Value, err = pq.db.Get(item.Key, nil); err != nil {
return nil, err
}
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5851
|
init
|
train
|
func (pq *PrefixQueue) init() error {
// Get the main prefix queue data.
val, err := pq.db.Get(pq.getDataKey(), nil)
if err == errors.ErrNotFound {
return nil
} else if err != nil {
return err
}
pq.size = binary.BigEndian.Uint64(val)
return nil
}
|
go
|
{
"resource": ""
}
|
q5852
|
generateKeyPrefixID
|
train
|
func generateKeyPrefixID(prefix []byte, id uint64) []byte {
// Handle the prefix.
key := append(prefix, prefixDelimiter)
// Handle the item ID.
key = append(key, idToKey(id)...)
return key
}
|
go
|
{
"resource": ""
}
|
q5853
|
OpenPriorityQueue
|
train
|
func OpenPriorityQueue(dataDir string, order order) (*PriorityQueue, error) {
var err error
// Create a new PriorityQueue.
pq := &PriorityQueue{
DataDir: dataDir,
db: &leveldb.DB{},
order: order,
isOpen: false,
}
// Open database for the priority queue.
pq.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return pq, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goquePriorityQueue)
if err != nil {
return pq, err
}
if !ok {
return pq, ErrIncompatibleType
}
// Set isOpen and return.
pq.isOpen = true
return pq, pq.init()
}
|
go
|
{
"resource": ""
}
|
q5854
|
Enqueue
|
train
|
func (pq *PriorityQueue) Enqueue(priority uint8, value []byte) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Get the priorityLevel.
level := pq.levels[priority]
// Create new PriorityItem.
item := &PriorityItem{
ID: level.tail + 1,
Priority: priority,
Key: pq.generateKey(priority, level.tail+1),
Value: value,
}
// Add it to the priority queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
// Increment tail position.
level.tail++
// If this priority level is more important than the curLevel.
if pq.cmpAsc(priority) || pq.cmpDesc(priority) {
pq.curLevel = priority
}
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5855
|
Dequeue
|
train
|
func (pq *PriorityQueue) Dequeue() (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item.
item, err := pq.getNextItem()
if err != nil {
return nil, err
}
// Remove this item from the priority queue.
if err = pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
pq.levels[pq.curLevel].head++
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5856
|
DequeueByPriority
|
train
|
func (pq *PriorityQueue) DequeueByPriority(priority uint8) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the given priority level.
item, err := pq.getItemByPriorityID(priority, pq.levels[priority].head+1)
if err != nil {
return nil, err
}
// Remove this item from the priority queue.
if err = pq.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Increment head position.
pq.levels[priority].head++
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5857
|
Peek
|
train
|
func (pq *PriorityQueue) Peek() (*PriorityItem, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
return pq.getNextItem()
}
|
go
|
{
"resource": ""
}
|
q5858
|
PeekByPriorityID
|
train
|
func (pq *PriorityQueue) PeekByPriorityID(priority uint8, id uint64) (*PriorityItem, error) {
pq.RLock()
defer pq.RUnlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
return pq.getItemByPriorityID(priority, id)
}
|
go
|
{
"resource": ""
}
|
q5859
|
Update
|
train
|
func (pq *PriorityQueue) Update(priority uint8, id uint64, newValue []byte) (*PriorityItem, error) {
pq.Lock()
defer pq.Unlock()
// Check if queue is closed.
if !pq.isOpen {
return nil, ErrDBClosed
}
// Check if item exists in queue.
if id <= pq.levels[priority].head || id > pq.levels[priority].tail {
return nil, ErrOutOfBounds
}
// Create new PriorityItem.
item := &PriorityItem{
ID: id,
Priority: priority,
Key: pq.generateKey(priority, id),
Value: newValue,
}
// Update this item in the queue.
if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5860
|
Length
|
train
|
func (pq *PriorityQueue) Length() uint64 {
pq.RLock()
defer pq.RUnlock()
var length uint64
for _, v := range pq.levels {
length += v.length()
}
return length
}
|
go
|
{
"resource": ""
}
|
q5861
|
Close
|
train
|
func (pq *PriorityQueue) Close() error {
pq.Lock()
defer pq.Unlock()
// Check if queue is already closed.
if !pq.isOpen {
return nil
}
// Close the LevelDB database.
if err := pq.db.Close(); err != nil {
return err
}
// Reset head and tail of each priority level
// and set isOpen to false.
for i := 0; i <= 255; i++ {
pq.levels[uint8(i)].head = 0
pq.levels[uint8(i)].tail = 0
}
pq.isOpen = false
return nil
}
|
go
|
{
"resource": ""
}
|
q5862
|
cmpAsc
|
train
|
func (pq *PriorityQueue) cmpAsc(priority uint8) bool {
return pq.order == ASC && priority < pq.curLevel
}
|
go
|
{
"resource": ""
}
|
q5863
|
cmpDesc
|
train
|
func (pq *PriorityQueue) cmpDesc(priority uint8) bool {
return pq.order == DESC && priority > pq.curLevel
}
|
go
|
{
"resource": ""
}
|
q5864
|
resetCurrentLevel
|
train
|
func (pq *PriorityQueue) resetCurrentLevel() {
if pq.order == ASC {
pq.curLevel = 255
} else if pq.order == DESC {
pq.curLevel = 0
}
}
|
go
|
{
"resource": ""
}
|
q5865
|
findOffset
|
train
|
func (pq *PriorityQueue) findOffset(offset uint64) (*PriorityItem, error) {
var length uint64
var curLevel uint8 = pq.curLevel
var newLevel int
// Handle newLevel initialization for descending order.
if pq.order == DESC {
newLevel = 255
}
// For condition expression.
condExpr := func(level int) bool {
if pq.order == ASC {
return level <= 255
}
return level >= 0
}
// For loop expression.
loopExpr := func(level *int) {
if pq.order == ASC {
*level++
} else if pq.order == DESC {
*level--
}
}
// Level comparison.
cmpLevels := func(newLevel, curLevel uint8) bool {
if pq.order == ASC {
return newLevel >= curLevel
}
return newLevel <= curLevel
}
// Loop through the priority levels.
for ; condExpr(newLevel); loopExpr(&newLevel) {
// If this level is lower than the current level based on ordering and contains items.
if cmpLevels(uint8(newLevel), curLevel) && pq.levels[uint8(newLevel)].length() > 0 {
curLevel = uint8(newLevel)
newLength := pq.levels[curLevel].length()
// If the offset is within the current priority level.
if length+newLength >= offset+1 {
return pq.getItemByPriorityID(curLevel, offset-length+1)
}
length += newLength
}
}
return nil, ErrOutOfBounds
}
|
go
|
{
"resource": ""
}
|
q5866
|
getNextItem
|
train
|
func (pq *PriorityQueue) getNextItem() (*PriorityItem, error) {
// If the current priority level is empty.
if pq.levels[pq.curLevel].length() == 0 {
// Set starting value for curLevel.
pq.resetCurrentLevel()
// Try to get the next priority level.
for i := 0; i <= 255; i++ {
if (pq.cmpAsc(uint8(i)) || pq.cmpDesc(uint8(i))) && pq.levels[uint8(i)].length() > 0 {
pq.curLevel = uint8(i)
}
}
// If still empty, return queue empty error.
if pq.levels[pq.curLevel].length() == 0 {
return nil, ErrEmpty
}
}
// Try to get the next item in the current priority level.
return pq.getItemByPriorityID(pq.curLevel, pq.levels[pq.curLevel].head+1)
}
|
go
|
{
"resource": ""
}
|
q5867
|
generatePrefix
|
train
|
func (pq *PriorityQueue) generatePrefix(level uint8) []byte {
// priority + prefixSep = 1 + 1 = 2
prefix := make([]byte, 2)
prefix[0] = byte(level)
prefix[1] = prefixSep[0]
return prefix
}
|
go
|
{
"resource": ""
}
|
q5868
|
generateKey
|
train
|
func (pq *PriorityQueue) generateKey(priority uint8, id uint64) []byte {
// prefix + key = 2 + 8 = 10
key := make([]byte, 10)
copy(key[0:2], pq.generatePrefix(priority))
copy(key[2:], idToKey(id))
return key
}
|
go
|
{
"resource": ""
}
|
q5869
|
init
|
train
|
func (pq *PriorityQueue) init() error {
// Set starting value for curLevel.
pq.resetCurrentLevel()
// Loop through each priority level.
for i := 0; i <= 255; i++ {
// Create a new LevelDB Iterator for this priority level.
prefix := pq.generatePrefix(uint8(i))
iter := pq.db.NewIterator(util.BytesPrefix(prefix), nil)
// Create a new priorityLevel.
pl := &priorityLevel{
head: 0,
tail: 0,
}
// Set priority level head to the first item.
if iter.First() {
pl.head = keyToID(iter.Key()[2:]) - 1
// Since this priority level has item(s), handle updating curLevel.
if pq.cmpAsc(uint8(i)) || pq.cmpDesc(uint8(i)) {
pq.curLevel = uint8(i)
}
}
// Set priority level tail to the last item.
if iter.Last() {
pl.tail = keyToID(iter.Key()[2:])
}
if iter.Error() != nil {
return iter.Error()
}
pq.levels[i] = pl
iter.Release()
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5870
|
idToKey
|
train
|
func idToKey(id uint64) []byte {
key := make([]byte, 8)
binary.BigEndian.PutUint64(key, id)
return key
}
|
go
|
{
"resource": ""
}
|
q5871
|
OpenStack
|
train
|
func OpenStack(dataDir string) (*Stack, error) {
var err error
// Create a new Stack.
s := &Stack{
DataDir: dataDir,
db: &leveldb.DB{},
head: 0,
tail: 0,
isOpen: false,
}
// Open database for the stack.
s.db, err = leveldb.OpenFile(dataDir, nil)
if err != nil {
return s, err
}
// Check if this Goque type can open the requested data directory.
ok, err := checkGoqueType(dataDir, goqueStack)
if err != nil {
return s, err
}
if !ok {
return s, ErrIncompatibleType
}
// Set isOpen and return.
s.isOpen = true
return s, s.init()
}
|
go
|
{
"resource": ""
}
|
q5872
|
Push
|
train
|
func (s *Stack) Push(value []byte) (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Create new Item.
item := &Item{
ID: s.head + 1,
Key: idToKey(s.head + 1),
Value: value,
}
// Add it to the stack.
if err := s.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
// Increment head position.
s.head++
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5873
|
PushString
|
train
|
func (s *Stack) PushString(value string) (*Item, error) {
return s.Push([]byte(value))
}
|
go
|
{
"resource": ""
}
|
q5874
|
Pop
|
train
|
func (s *Stack) Pop() (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Try to get the next item in the stack.
item, err := s.getItemByID(s.head)
if err != nil {
return nil, err
}
// Remove this item from the stack.
if err := s.db.Delete(item.Key, nil); err != nil {
return nil, err
}
// Decrement head position.
s.head--
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5875
|
Peek
|
train
|
func (s *Stack) Peek() (*Item, error) {
s.RLock()
defer s.RUnlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
return s.getItemByID(s.head)
}
|
go
|
{
"resource": ""
}
|
q5876
|
PeekByOffset
|
train
|
func (s *Stack) PeekByOffset(offset uint64) (*Item, error) {
s.RLock()
defer s.RUnlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
return s.getItemByID(s.head - offset)
}
|
go
|
{
"resource": ""
}
|
q5877
|
Update
|
train
|
func (s *Stack) Update(id uint64, newValue []byte) (*Item, error) {
s.Lock()
defer s.Unlock()
// Check if stack is closed.
if !s.isOpen {
return nil, ErrDBClosed
}
// Check if item exists in stack.
if id > s.head || id <= s.tail {
return nil, ErrOutOfBounds
}
// Create new Item.
item := &Item{
ID: id,
Key: idToKey(id),
Value: newValue,
}
// Update this item in the stack.
if err := s.db.Put(item.Key, item.Value, nil); err != nil {
return nil, err
}
return item, nil
}
|
go
|
{
"resource": ""
}
|
q5878
|
Close
|
train
|
func (s *Stack) Close() error {
s.Lock()
defer s.Unlock()
// Check if stack is already closed.
if !s.isOpen {
return nil
}
// Close the LevelDB database.
if err := s.db.Close(); err != nil {
return err
}
// Reset stack head and tail and set
// isOpen to false.
s.head = 0
s.tail = 0
s.isOpen = false
return nil
}
|
go
|
{
"resource": ""
}
|
q5879
|
Drop
|
train
|
func (s *Stack) Drop() error {
if err := s.Close(); err != nil {
return err
}
return os.RemoveAll(s.DataDir)
}
|
go
|
{
"resource": ""
}
|
q5880
|
init
|
train
|
func (s *Stack) init() error {
// Create a new LevelDB Iterator.
iter := s.db.NewIterator(nil, nil)
defer iter.Release()
// Set stack head to the last item.
if iter.Last() {
s.head = keyToID(iter.Key())
}
// Set stack tail to the first item.
if iter.First() {
s.tail = keyToID(iter.Key()) - 1
}
return iter.Error()
}
|
go
|
{
"resource": ""
}
|
q5881
|
RetrieveAssertionInfo
|
train
|
func (sp *SAMLServiceProvider) RetrieveAssertionInfo(encodedResponse string) (*AssertionInfo, error) {
assertionInfo := &AssertionInfo{
Values: make(Values),
}
response, err := sp.ValidateEncodedResponse(encodedResponse)
if err != nil {
return nil, ErrVerification{Cause: err}
}
// TODO: Support multiple assertions
if len(response.Assertions) == 0 {
return nil, ErrMissingAssertion
}
assertion := response.Assertions[0]
assertionInfo.Assertions = response.Assertions
assertionInfo.ResponseSignatureValidated = response.SignatureValidated
warningInfo, err := sp.VerifyAssertionConditions(&assertion)
if err != nil {
return nil, err
}
//Get the NameID
subject := assertion.Subject
if subject == nil {
return nil, ErrMissingElement{Tag: SubjectTag}
}
nameID := subject.NameID
if nameID == nil {
return nil, ErrMissingElement{Tag: NameIdTag}
}
assertionInfo.NameID = nameID.Value
//Get the actual assertion attributes
attributeStatement := assertion.AttributeStatement
if attributeStatement == nil && !sp.AllowMissingAttributes {
return nil, ErrMissingElement{Tag: AttributeStatementTag}
}
if attributeStatement != nil {
for _, attribute := range attributeStatement.Attributes {
assertionInfo.Values[attribute.Name] = attribute
}
}
if assertion.AuthnStatement != nil {
if assertion.AuthnStatement.AuthnInstant != nil {
assertionInfo.AuthnInstant = assertion.AuthnStatement.AuthnInstant
}
if assertion.AuthnStatement.SessionNotOnOrAfter != nil {
assertionInfo.SessionNotOnOrAfter = assertion.AuthnStatement.SessionNotOnOrAfter
}
}
assertionInfo.WarningInfo = warningInfo
return assertionInfo, nil
}
|
go
|
{
"resource": ""
}
|
q5882
|
BuildAuthURL
|
train
|
func (sp *SAMLServiceProvider) BuildAuthURL(relayState string) (string, error) {
doc, err := sp.BuildAuthRequestDocument()
if err != nil {
return "", err
}
return sp.BuildAuthURLFromDocument(relayState, doc)
}
|
go
|
{
"resource": ""
}
|
q5883
|
AuthRedirect
|
train
|
func (sp *SAMLServiceProvider) AuthRedirect(w http.ResponseWriter, r *http.Request, relayState string) (err error) {
url, err := sp.BuildAuthURL(relayState)
if err != nil {
return err
}
http.Redirect(w, r, url, http.StatusFound)
return nil
}
|
go
|
{
"resource": ""
}
|
q5884
|
validateResponseAttributes
|
train
|
func (sp *SAMLServiceProvider) validateResponseAttributes(response *types.Response) error {
if response.Destination != "" && response.Destination != sp.AssertionConsumerServiceURL {
return ErrInvalidValue{
Key: DestinationAttr,
Expected: sp.AssertionConsumerServiceURL,
Actual: response.Destination,
}
}
if response.Version != "2.0" {
return ErrInvalidValue{
Reason: ReasonUnsupported,
Key: "SAML version",
Expected: "2.0",
Actual: response.Version,
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5885
|
ValidateEncodedResponse
|
train
|
func (sp *SAMLServiceProvider) ValidateEncodedResponse(encodedResponse string) (*types.Response, error) {
raw, err := base64.StdEncoding.DecodeString(encodedResponse)
if err != nil {
return nil, err
}
// Parse the raw response
doc, el, err := parseResponse(raw)
if err != nil {
return nil, err
}
var responseSignatureValidated bool
if !sp.SkipSignatureValidation {
el, err = sp.validateElementSignature(el)
if err == dsig.ErrMissingSignature {
// Unfortunately we just blew away our Response
el = doc.Root()
} else if err != nil {
return nil, err
} else if el == nil {
return nil, fmt.Errorf("missing transformed response")
} else {
responseSignatureValidated = true
}
}
err = sp.decryptAssertions(el)
if err != nil {
return nil, err
}
var assertionSignaturesValidated bool
if !sp.SkipSignatureValidation {
err = sp.validateAssertionSignatures(el)
if err == dsig.ErrMissingSignature {
if !responseSignatureValidated {
return nil, fmt.Errorf("response and/or assertions must be signed")
}
} else if err != nil {
return nil, err
} else {
assertionSignaturesValidated = true
}
}
decodedResponse := &types.Response{}
err = xmlUnmarshalElement(el, decodedResponse)
if err != nil {
return nil, fmt.Errorf("unable to unmarshal response: %v", err)
}
decodedResponse.SignatureValidated = responseSignatureValidated
if assertionSignaturesValidated {
for idx := 0; idx < len(decodedResponse.Assertions); idx++ {
decodedResponse.Assertions[idx].SignatureValidated = true
}
}
err = sp.Validate(decodedResponse)
if err != nil {
return nil, err
}
return decodedResponse, nil
}
|
go
|
{
"resource": ""
}
|
q5886
|
DecodeUnverifiedBaseResponse
|
train
|
func DecodeUnverifiedBaseResponse(encodedResponse string) (*types.UnverifiedBaseResponse, error) {
raw, err := base64.StdEncoding.DecodeString(encodedResponse)
if err != nil {
return nil, err
}
var response *types.UnverifiedBaseResponse
err = maybeDeflate(raw, func(maybeXML []byte) error {
response = &types.UnverifiedBaseResponse{}
return xml.Unmarshal(maybeXML, response)
})
if err != nil {
return nil, err
}
return response, nil
}
|
go
|
{
"resource": ""
}
|
q5887
|
maybeDeflate
|
train
|
func maybeDeflate(data []byte, decoder func([]byte) error) error {
err := decoder(data)
if err == nil {
return nil
}
deflated, err := ioutil.ReadAll(flate.NewReader(bytes.NewReader(data)))
if err != nil {
return err
}
return decoder(deflated)
}
|
go
|
{
"resource": ""
}
|
q5888
|
parseResponse
|
train
|
func parseResponse(xml []byte) (*etree.Document, *etree.Element, error) {
var doc *etree.Document
err := maybeDeflate(xml, func(xml []byte) error {
doc = etree.NewDocument()
return doc.ReadFromBytes(xml)
})
if err != nil {
return nil, nil, err
}
el := doc.Root()
if el == nil {
return nil, nil, fmt.Errorf("unable to parse response")
}
return doc, el, nil
}
|
go
|
{
"resource": ""
}
|
q5889
|
Decrypt
|
train
|
func (ea *EncryptedAssertion) Decrypt(cert *tls.Certificate) (*Assertion, error) {
plaintext, err := ea.DecryptBytes(cert)
if err != nil {
return nil, fmt.Errorf("Error decrypting assertion: %v", err)
}
assertion := &Assertion{}
err = xml.Unmarshal(plaintext, assertion)
if err != nil {
return nil, fmt.Errorf("Error unmarshaling assertion: %v", err)
}
return assertion, nil
}
|
go
|
{
"resource": ""
}
|
q5890
|
DecryptSymmetricKey
|
train
|
func (ek *EncryptedKey) DecryptSymmetricKey(cert *tls.Certificate) (cipher.Block, error) {
if len(cert.Certificate) < 1 {
return nil, fmt.Errorf("decryption tls.Certificate has no public certs attached")
}
// The EncryptedKey may or may not include X509Data (certificate).
// If included, the EncryptedKey certificate:
// - is FYI only (fail if it does not match the SP certificate)
// - is NOT used to decrypt CipherData
if ek.X509Data != "" {
if encCert, err := base64.StdEncoding.DecodeString(ek.X509Data); err != nil {
return nil, fmt.Errorf("error decoding EncryptedKey certificate: %v", err)
} else if !bytes.Equal(cert.Certificate[0], encCert) {
return nil, fmt.Errorf("key decryption attempted with mismatched cert, SP cert(%.11s), assertion cert(%.11s)",
debugKeyFp(cert.Certificate[0]), debugKeyFp(encCert))
}
}
cipherText, err := base64.StdEncoding.DecodeString(ek.CipherValue)
if err != nil {
return nil, err
}
switch pk := cert.PrivateKey.(type) {
case *rsa.PrivateKey:
var h hash.Hash
switch ek.EncryptionMethod.DigestMethod.Algorithm {
case "", MethodSHA1:
h = sha1.New() // default
case MethodSHA256:
h = sha256.New()
case MethodSHA512:
h = sha512.New()
default:
return nil, fmt.Errorf("unsupported digest algorithm: %v",
ek.EncryptionMethod.DigestMethod.Algorithm)
}
switch ek.EncryptionMethod.Algorithm {
case "":
return nil, fmt.Errorf("missing encryption algorithm")
case MethodRSAOAEP, MethodRSAOAEP2:
pt, err := rsa.DecryptOAEP(h, rand.Reader, pk, cipherText, nil)
if err != nil {
return nil, fmt.Errorf("rsa internal error: %v", err)
}
b, err := aes.NewCipher(pt)
if err != nil {
return nil, err
}
return b, nil
default:
return nil, fmt.Errorf("unsupported encryption algorithm: %s", ek.EncryptionMethod.Algorithm)
}
}
return nil, fmt.Errorf("no cipher for decoding symmetric key")
}
|
go
|
{
"resource": ""
}
|
q5891
|
VerifyAssertionConditions
|
train
|
func (sp *SAMLServiceProvider) VerifyAssertionConditions(assertion *types.Assertion) (*WarningInfo, error) {
warningInfo := &WarningInfo{}
now := sp.Clock.Now()
conditions := assertion.Conditions
if conditions == nil {
return nil, ErrMissingElement{Tag: ConditionsTag}
}
if conditions.NotBefore == "" {
return nil, ErrMissingElement{Tag: ConditionsTag, Attribute: NotBeforeAttr}
}
notBefore, err := time.Parse(time.RFC3339, conditions.NotBefore)
if err != nil {
return nil, ErrParsing{Tag: NotBeforeAttr, Value: conditions.NotBefore, Type: "time.RFC3339"}
}
if now.Before(notBefore) {
warningInfo.InvalidTime = true
}
if conditions.NotOnOrAfter == "" {
return nil, ErrMissingElement{Tag: ConditionsTag, Attribute: NotOnOrAfterAttr}
}
notOnOrAfter, err := time.Parse(time.RFC3339, conditions.NotOnOrAfter)
if err != nil {
return nil, ErrParsing{Tag: NotOnOrAfterAttr, Value: conditions.NotOnOrAfter, Type: "time.RFC3339"}
}
if now.After(notOnOrAfter) {
warningInfo.InvalidTime = true
}
for _, audienceRestriction := range conditions.AudienceRestrictions {
matched := false
for _, audience := range audienceRestriction.Audiences {
if audience.Value == sp.AudienceURI {
matched = true
break
}
}
if !matched {
warningInfo.NotInAudience = true
break
}
}
if conditions.OneTimeUse != nil {
warningInfo.OneTimeUse = true
}
proxyRestriction := conditions.ProxyRestriction
if proxyRestriction != nil {
proxyRestrictionInfo := &ProxyRestriction{
Count: proxyRestriction.Count,
Audience: []string{},
}
for _, audience := range proxyRestriction.Audience {
proxyRestrictionInfo.Audience = append(proxyRestrictionInfo.Audience, audience.Value)
}
warningInfo.ProxyRestriction = proxyRestrictionInfo
}
return warningInfo, nil
}
|
go
|
{
"resource": ""
}
|
q5892
|
Validate
|
train
|
func (sp *SAMLServiceProvider) Validate(response *types.Response) error {
err := sp.validateResponseAttributes(response)
if err != nil {
return err
}
if len(response.Assertions) == 0 {
return ErrMissingAssertion
}
issuer := response.Issuer
if issuer == nil {
// FIXME?: SAML Core 2.0 Section 3.2.2 has Response.Issuer as [Optional]
return ErrMissingElement{Tag: IssuerTag}
}
if sp.IdentityProviderIssuer != "" && response.Issuer.Value != sp.IdentityProviderIssuer {
return ErrInvalidValue{
Key: IssuerTag,
Expected: sp.IdentityProviderIssuer,
Actual: response.Issuer.Value,
}
}
status := response.Status
if status == nil {
return ErrMissingElement{Tag: StatusTag}
}
statusCode := status.StatusCode
if statusCode == nil {
return ErrMissingElement{Tag: StatusCodeTag}
}
if statusCode.Value != StatusCodeSuccess {
return ErrInvalidValue{
Key: StatusCodeTag,
Expected: StatusCodeSuccess,
Actual: statusCode.Value,
}
}
for _, assertion := range response.Assertions {
issuer = assertion.Issuer
if issuer == nil {
return ErrMissingElement{Tag: IssuerTag}
}
if sp.IdentityProviderIssuer != "" && assertion.Issuer.Value != sp.IdentityProviderIssuer {
return ErrInvalidValue{
Key: IssuerTag,
Expected: sp.IdentityProviderIssuer,
Actual: issuer.Value,
}
}
subject := assertion.Subject
if subject == nil {
return ErrMissingElement{Tag: SubjectTag}
}
subjectConfirmation := subject.SubjectConfirmation
if subjectConfirmation == nil {
return ErrMissingElement{Tag: SubjectConfirmationTag}
}
if subjectConfirmation.Method != SubjMethodBearer {
return ErrInvalidValue{
Reason: ReasonUnsupported,
Key: SubjectConfirmationTag,
Expected: SubjMethodBearer,
Actual: subjectConfirmation.Method,
}
}
subjectConfirmationData := subjectConfirmation.SubjectConfirmationData
if subjectConfirmationData == nil {
return ErrMissingElement{Tag: SubjectConfirmationDataTag}
}
if subjectConfirmationData.Recipient != sp.AssertionConsumerServiceURL {
return ErrInvalidValue{
Key: RecipientAttr,
Expected: sp.AssertionConsumerServiceURL,
Actual: subjectConfirmationData.Recipient,
}
}
if subjectConfirmationData.NotOnOrAfter == "" {
return ErrMissingElement{Tag: SubjectConfirmationDataTag, Attribute: NotOnOrAfterAttr}
}
notOnOrAfter, err := time.Parse(time.RFC3339, subjectConfirmationData.NotOnOrAfter)
if err != nil {
return ErrParsing{Tag: NotOnOrAfterAttr, Value: subjectConfirmationData.NotOnOrAfter, Type: "time.RFC3339"}
}
now := sp.Clock.Now()
if now.After(notOnOrAfter) {
return ErrInvalidValue{
Reason: ReasonExpired,
Key: NotOnOrAfterAttr,
Expected: now.Format(time.RFC3339),
Actual: subjectConfirmationData.NotOnOrAfter,
}
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5893
|
makeTermios2
|
train
|
func makeTermios2(options OpenOptions) (*termios2, error) {
// Sanity check inter-character timeout and minimum read size options.
vtime := uint(round(float64(options.InterCharacterTimeout)/100.0) * 100)
vmin := options.MinimumReadSize
if vmin == 0 && vtime < 100 {
return nil, errors.New("invalid values for InterCharacterTimeout and MinimumReadSize")
}
if vtime > 25500 {
return nil, errors.New("invalid value for InterCharacterTimeout")
}
ccOpts := [kNCCS]cc_t{}
ccOpts[syscall.VTIME] = cc_t(vtime / 100)
ccOpts[syscall.VMIN] = cc_t(vmin)
t2 := &termios2{
c_cflag: syscall.CLOCAL | syscall.CREAD | kBOTHER,
c_ispeed: speed_t(options.BaudRate),
c_ospeed: speed_t(options.BaudRate),
c_cc: ccOpts,
}
switch options.StopBits {
case 1:
case 2:
t2.c_cflag |= syscall.CSTOPB
default:
return nil, errors.New("invalid setting for StopBits")
}
switch options.ParityMode {
case PARITY_NONE:
case PARITY_ODD:
t2.c_cflag |= syscall.PARENB
t2.c_cflag |= syscall.PARODD
case PARITY_EVEN:
t2.c_cflag |= syscall.PARENB
default:
return nil, errors.New("invalid setting for ParityMode")
}
switch options.DataBits {
case 5:
t2.c_cflag |= syscall.CS5
case 6:
t2.c_cflag |= syscall.CS6
case 7:
t2.c_cflag |= syscall.CS7
case 8:
t2.c_cflag |= syscall.CS8
default:
return nil, errors.New("invalid setting for DataBits")
}
if options.RTSCTSFlowControl {
t2.c_cflag |= unix.CRTSCTS
}
return t2, nil
}
|
go
|
{
"resource": ""
}
|
q5894
|
setTermios
|
train
|
func setTermios(fd uintptr, src *termios) error {
// Make the ioctl syscall that sets the termios struct.
r1, _, errno :=
syscall.Syscall(
syscall.SYS_IOCTL,
fd,
uintptr(kTIOCSETA),
uintptr(unsafe.Pointer(src)))
// Did the syscall return an error?
if errno != 0 {
return os.NewSyscallError("SYS_IOCTL", errno)
}
// Just in case, check the return value as well.
if r1 != 0 {
return errors.New("Unknown error from SYS_IOCTL.")
}
return nil
}
|
go
|
{
"resource": ""
}
|
q5895
|
Execute
|
train
|
func (ws *windowsService) Execute(args []string, r <-chan wsvc.ChangeRequest, changes chan<- wsvc.Status) (bool, uint32) {
const cmdsAccepted = wsvc.AcceptStop | wsvc.AcceptShutdown
changes <- wsvc.Status{State: wsvc.StartPending}
if err := ws.i.Start(); err != nil {
ws.setError(err)
return true, 1
}
changes <- wsvc.Status{State: wsvc.Running, Accepts: cmdsAccepted}
loop:
for {
c := <-r
switch c.Cmd {
case wsvc.Interrogate:
changes <- c.CurrentStatus
case wsvc.Stop, wsvc.Shutdown:
changes <- wsvc.Status{State: wsvc.StopPending}
err := ws.i.Stop()
if err != nil {
ws.setError(err)
return true, 2
}
break loop
default:
continue loop
}
}
return false, 0
}
|
go
|
{
"resource": ""
}
|
q5896
|
Run
|
train
|
func Run(service Service, sig ...os.Signal) error {
env := environment{}
if err := service.Init(env); err != nil {
return err
}
if err := service.Start(); err != nil {
return err
}
if len(sig) == 0 {
sig = []os.Signal{syscall.SIGINT, syscall.SIGTERM}
}
signalChan := make(chan os.Signal, 1)
signalNotify(signalChan, sig...)
<-signalChan
return service.Stop()
}
|
go
|
{
"resource": ""
}
|
q5897
|
NewSwitch
|
train
|
func NewSwitch(Cond node.Node, CaseList *CaseList) *Switch {
return &Switch{
FreeFloating: nil,
Cond: Cond,
CaseList: CaseList,
}
}
|
go
|
{
"resource": ""
}
|
q5898
|
NewConstant
|
train
|
func NewConstant(ConstantName node.Node, Expr node.Node, PhpDocComment string) *Constant {
return &Constant{
FreeFloating: nil,
PhpDocComment: PhpDocComment,
ConstantName: ConstantName,
Expr: Expr,
}
}
|
go
|
{
"resource": ""
}
|
q5899
|
NewIdentical
|
train
|
func NewIdentical(Variable node.Node, Expression node.Node) *Identical {
return &Identical{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.