text:
@inproceedings{10.1145/3248282,
author = {Aho, Alfred V.},
title = {Session Details: Session 1},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3248282},
doi = {10.1145/3248282},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588113,
author = {Atzeni, Paolo and Parker, D. Stott},
title = {Assumptions in Relational Database Theory},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588113},
doi = {10.1145/588111.588113},
abstract = {Many results in relational database theory on the structure of dependencies, query languages, and databases in general have now been established. However, neither (a) the reliance of these results on various assumptions, nor (b) the desirability or reasonableness of these assumptions themselves have been closely examined. These assumptions are nontrivial: examples include the universal relation assumption and the lossless join assumption.The purpose of the present paper is to clarify many of the existing assumptions, and point out weaknesses. This is desirable both to harden the statements of previous results, and to evaluate recent suggestions that certain assumptions (such as the acyclic JD assumption) may be useful for modeling "real world" databases. Specifically, studies are made of assumptions made for (1) universal relations, (2) functional dependency inference, and (3) decomposition theory. We show that:• Some assumptions (such as uniqueness of relationships among attributes) can be more powerful than they appear;• common treatment of FDs is sometimes inappropriate, and for example FD inferences such as {A → B, B → C} |= A → C can be incorrect;• the 'decomposition' approach to design may be hard to justify in real terms; and• Acyclic JDs may have drawbacks in eliminating ambiguity in queries and in modeling real enterprises.It is hoped that this exposition will help clarify some confusing issues in this field, and will lead to a better understanding of which assumptions are reasonable and useful in modeling the "real world".},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {1–9},
numpages = {9},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588114,
author = {Ullman, Jeffrey D.},
title = {The U. R. Strikes Back},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588114},
doi = {10.1145/588111.588114},
abstract = {In this paper, we try to put to rest many of the objections to the universal relation concept that have appeared in the literature. First, we shall taxonomize the varieties of ideas that are sometimes called the "universal relation assumption." Then, we consider some of the arguments pro and con. In some cases, the arguments against were expressed prematurely, and solutions to the problems they expose have since been found. In other cases, the arguments against are simply fallacious. In still other cases, the problems pointed out are real, but simply serve to point out that the advantages of the universal relation are not gotten for free. We shall conclude the paper with a description of the algorithm used to interpret queries in System/U, and the reasoning behind it.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {10–22},
numpages = {13},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/3248283,
author = {Fagin, Ronald},
title = {Session Details: Session 2},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3248283},
doi = {10.1145/3248283},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588116,
author = {Rissanen, Jorma},
title = {On Equivalences of Database Schemes},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588116},
doi = {10.1145/588111.588116},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {23–26},
numpages = {4},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588117,
author = {Zaniolo, Carlo},
title = {Database Relations with Null Values},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588117},
doi = {10.1145/588111.588117},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {27–33},
numpages = {7},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588118,
author = {Maier, David and Ullman, Jeffrey D.},
title = {Connections in Acyclic Hypergraphs: Extended Abstract},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588118},
doi = {10.1145/588111.588118},
abstract = {We demonstrate a sense in which the equivalence between blocks (subgraphs without articulation points) and biconnected components (subgraphs in which there are two edge-disjoint paths between any pair of nodes) that holds in ordinary graph theory can be generalized to hypergraphs. The result has an interpretation for relational databases that the universal relations described by acyclic join dependencies are exactly those for which the connections among attributes are defined uniquely. We also exhibit a relationship between the process of Graham reduction [6] of hypergraphs and the process of tableau reduction [1] that holds only for acyclic hypergraphs.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {34–39},
numpages = {6},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588119,
author = {Goodman, N. and Shmueli, O.},
title = {The Tree Property is Fundamental for Query Processing},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588119},
doi = {10.1145/588111.588119},
abstract = {One can partition the class of relational database schemas into tree schemas and cyclic schemas. In this paper we examine query processing implications of the partitioning; other areas impacted include dependency theory, schema design and graph theory.We consider a class of queries that compute the join of all relations in the database projected onto a prescribed set of attributes. We show that solving such queries (using the join, project and semijoin operators) is tantamount to creating an "embedded" tree schema which we call a tree projection. This lends further credibility to the pivotal nature of the tree/cyclic partitioning.Using the tree projection concept we analyze the problem of determining how many joins are needed to solve a query.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {40–48},
numpages = {9},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588120,
author = {Goodman, N. and Shmueli, O.},
title = {Transforming Cyclic Schemas into Trees},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588120},
doi = {10.1145/588111.588120},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {49–54},
numpages = {6},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588121,
author = {Beeri, Catriel and Korth, Henry F.},
title = {Compatible Attributes in a Universal Relation},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588121},
doi = {10.1145/588111.588121},
abstract = {The problem of entities that play multiple roles in a relational database is studied, with an emphasis on the universal relation view of the database. A tree structure is used to describe the compatibilities among attributes. The compatibility information for an attribute encodes role playing information that cannot be described by traditional data dependencies. This structure is used to define the semantics of a QUEL-like (Stonebraker et al. [1976]) query language that uses special naming rules to permit easy use of attribute compatibility},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {55–62},
numpages = {8},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/3248284,
author = {Bernstein, P. A.},
title = {Session Details: Session 3},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3248284},
doi = {10.1145/3248284},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588123,
author = {Lynch, Nancy A.},
title = {Multilevel Atomicity},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588123},
doi = {10.1145/588111.588123},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {63–69},
numpages = {7},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588124,
author = {Fischer, Michael J. and Michael, Alan},
title = {Sacrificing Serializability to Attain High Availability of Data in an Unreliable Network},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588124},
doi = {10.1145/588111.588124},
abstract = {We present a simple algorithm for maintaining a replicated distributed dictionary which achieves high availability of data, rapid processing of atomic actions, efficient utilization of storage, and tolerance to node or network failures including lost or duplicated messages. It does not require transaction logs, synchronized clocks, or other complicated mechanisms for its operation. It achieves consistency contraints which are considerably weaker than serial consistency but nonetheless are adequate for many dictionary applications such as electronic appointment calendars and mail systems. The degree of consistency achieved depends on the particular history of operation of the system in a way that is intuitive and easily understood. The algorithm implements a "best effort" approximation to full serial consistency, relative to whatever internode communication has successfully taken place, so the semantics are fully specified even under partial failure of the system. Both the correctness of the algorithm and the utility of such weak semantics depend heavily on special properties of the dictionary operations.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {70–75},
numpages = {6},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588125,
author = {Papadimitriou, Christos H. and Kanellakis, Paris C.},
title = {On Concurrency Control by Multiple Versions},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588125},
doi = {10.1145/588111.588125},
abstract = {We examine the problem of concurrency control when the database management system supports multiple versions of the data. We characterize the limit of the parallelism achievable by the multiversion approach and demonstrate the resulting space-parallelism tradeoff.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {76–82},
numpages = {7},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588126,
author = {Reuter, Andreas},
title = {Concurrency on High-Traffic Data Elements},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588126},
doi = {10.1145/588111.588126},
abstract = {In many large database applications there are certain elements mostly containing aggregate information, which are very frequently referred to (read and modified) by many transactions. If access to such fields has to obey to conventional two-phase lock protocols (1,2), transactions will be serialized in front of these "hot spots", i.e. the degree of parallelism is reduced. To avoid this kind of lock contention some improved lock protocols have been proposed, the most interesting of which is the one implemented in IMS Fast Path (3,4), where add and subtract may be performed concurrently on numerical fields, since backout is always possible with the unique inverse of each operand. A similar scheme is proposed in (10). We expand this idea to parallel readers and writers on numerical data types, proving that under certain conditions the result of such concurrent operations is consistent in the sense that it is equal to some serial schedule (2,5).},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {83–92},
numpages = {10},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/3248285,
author = {Selinger, Pat},
title = {Session Details: Session 4},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3248285},
doi = {10.1145/3248285},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588128,
author = {Hadzilacos, Vassos},
title = {An Algorithm for Minimizing Roll Back Cost},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588128},
doi = {10.1145/588111.588128},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {93–97},
numpages = {5},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588129,
author = {Kanellakis, Paris C. and Papadimitriou, Christos H.},
title = {Is Distributed Locking Harder?},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588129},
doi = {10.1145/588111.588129},
abstract = {We examine the problem of determining whether a set of locked transactions, accessing a distributed database, is guaranteed to produce only serializable schedules. For a pair of transactions we prove that this concurrency control problem (which is polynomially solvable for centralized databases) is in general coNP-complete. We employ a new graph-theoretic technique and provide an efficient test for the special case of databases distributed between two sites only.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {98–107},
numpages = {10},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588130,
author = {Soisalon-Soininen, Eljas and Wood, Derick},
title = {An Optimal Algorithm for Testing for Safety and Detecting Deadlocks in Locked Transaction Systems},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588130},
doi = {10.1145/588111.588130},
abstract = {Various notions are introduced for the closure of a set of rectilinearly oriented rectangles on the plane. Optimal algorithms are presented for computing the closures. These algorithms imply optimal solutions to several problems related to database concurrency control.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {108–116},
numpages = {9},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/3248286,
author = {Rosenkrantz, Daniel J.},
title = {Session Details: Session 5},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3248286},
doi = {10.1145/3248286},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588132,
author = {Dayal, Umeshwar and Goodman, Nathan and Katz, Randy H.},
title = {An Extended Relational Algebra with Control over Duplicate Elimination},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588132},
doi = {10.1145/588111.588132},
abstract = {In the pure relational model, duplicate tuples are automatically eliminated. Some real world languages such as DAPLEX, however, give users control over duplicate elimination. This paper extends the relational model to include multiset relations, i.e., relations with duplicate tuples. It considers three formalisms for expressing queries in this model: extended relational algebra, tableaux, and DAPLEX. It shows that, as in the original algebra, the equivalence problem for conjunctive expressions in the extended algebra can be solved using tableaux, and is NP-complete. Finally, it demonstrates that the extended algebra and DAPLEX have essentially the same expressiveness relative to conjunctive expressions.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {117–123},
numpages = {7},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588133,
author = {Jaeschke, G. and Schek, H. J.},
title = {Remarks on the Algebra of Non First Normal Form Relations},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588133},
doi = {10.1145/588111.588133},
abstract = {Usually, the first normal form condition of the relational model of data is imposed. Presently, a broader class of data base applications like office information systems is considered where this restriction is not convenient. Therefore, an extension of the relational model is proposed consisting of Non First Normal Form (NF2) relations. The relational algebra is enriched mainly by so called nest and unnest operations which transform between NF2 relations and the usual ones. We state some properties of these operations and some rules which occur in combination with the operations of the usual relational algebra. Since we propose to use the NF2 model also for the internal data model these rules are important not only for theoretical reasons but also for a practical implementation.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {124–138},
numpages = {15},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588134,
author = {Reiss, Steven P. and Post, Mark J. and Dalenius, Tore},
title = {Non-Reversible Privacy Transformations},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588134},
doi = {10.1145/588111.588134},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {139–146},
numpages = {8},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588135,
author = {Kuck, Sharon McCure and Sagiv, Yehoshua},
title = {A Universal Relation Database System Implemented via the Network Model},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588135},
doi = {10.1145/588111.588135},
abstract = {We describe a network schema design algorithm that uses a well-designed relational schema as input. The resulting network database handles incomplete information, since we use only the modified foreign-key constraint and not the universal instance assumption. We believe that the representative instance is a correct representation of information stored in the database. We show how to map the representative instance to the network database. We give two algorithms for translating a relational query to a network application program. The first algorithm is confined to relational queries that express selections and projections over the universal relation scheme. The second algorithm includes all relational queries over select, project and (natural) join. Optimization techniques are discussed for both types of translation.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {147–157},
numpages = {11},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/3248287,
author = {Yu, C.},
title = {Session Details: Session 6},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3248287},
doi = {10.1145/3248287},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588137,
author = {Chandra, Ashok K. and Harel, David},
title = {Horn Clauses and the Fixpoint Query Hierarchy},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588137},
doi = {10.1145/588111.588137},
abstract = {A logic program consists of a set of Horn clauses, and can be used to express a query on relational data bases. It is shown that logic programs express precisely the queries in YE+ (the set of queries representable by a fixpoint applied to a positive existential query). Queries expressible by logic programs are thus not first order queries in general; nor are all the first order queries expressible as logic programs. A way of adding the negation operator to logic programs is suggested. The resulting set of clausal queries equals FP, the set of first order queries closed under fixpoints (as well as ¬, ∨, 3).},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {158–163},
numpages = {6},
keywords = {horn clause, logic program, query language, PROLOG, relational data base},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588138,
author = {Johnson, D. S. and Klug, A.},
title = {Testing Containment of Conjunctive Queries under Functional and Inclusion Dependencies},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588138},
doi = {10.1145/588111.588138},
abstract = {We consider the problem of optimizing conjunctive queries in the presence of inclusion and functional dependencies. We show that the problem of containment (and hence those of equivalence and non-minimality) is in NP when either (a) there are no functional dependencies or (b) the set of dependencies is what we call key-based. These results assume that infinite databases are allowed. If only finite databases are allowed, new containments may arise, as we illustrate by an example. We also prove a "compactness" theorem that shows that no such examples can exist for case (b).},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {164–169},
numpages = {6},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588139,
author = {Imielinski, Tomasz and Lipski, W.},
title = {The Relational Model of Data and Cylindrical Algebras},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588139},
doi = {10.1145/588111.588139},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {170},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/3248288,
author = {Dobkin, David P.},
title = {Session Details: Session 7},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3248288},
doi = {10.1145/3248288},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588141,
author = {Casanova, Marco A. and Fagin, Ronald and Papadimitriou, Christos H.},
title = {Inclusion Dependencies and Their Interaction with Functional Dependencies},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588141},
doi = {10.1145/588111.588141},
abstract = {Inclusion dependencies, or INDs (which can say, for example, that every manager is an employee) are studied, including their interaction with functional dependencies, or FDs. A simple complete axiomatization for INDs is presented, and the decision problem for INDs is shown to be PSPACE-complete. (The decision problem for INDs is the problem of determining whether or not Σ logically implies σ, given a set Σ of INDs and a single IND σ). It is shown that finite implication (implication over databases with a finite number of tuples) is the same as unrestricted implications for INDs, although finite implication and unrestricted implication are distinct for FDs and INDs taken together. It is shown that, although there are simple complete axiomatizations for FDs alone and for INDs alone, there is no complete axiomatization for FDs and INDs taken together, in which every rule is k-ary for some fixed k (and in particular, there is no finite complete axiomatization.) This is true whether we consider finite implication or unrestricted implication, and is true even if no relation scheme has more than three attributes. The nonexistence of a k-ary complete axiomatization for FDs and INDs taken together is proven by giving a condition which is necessary and sufficient in general for the existence of a k-ary complete axiomatization.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {171–176},
numpages = {6},
keywords = {relational database, inclusion dependency, functional dependency, PSPACE-complete, complete axiomatization},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588142,
author = {Graham, Marc H. and Mendelzon, Alberto O.},
title = {Notions of Dependency Satisfaction},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588142},
doi = {10.1145/588111.588142},
abstract = {Two notions of dependency satisfaction, consistency and completeness, are introduced. Consistency is the natural generalization of weak satisfaction and seems appropriate when only equality-generating dependencies are given, but disagrees with the standard notion in the presence of tuple-generating dependencies. Completeness is based on the intuitive semantics of tuple-generating dependencies but appears unnatural for equality-generating dependencies. It is argued that neither approach is the correct one, but rather that they correspond to different policies on constraint enforcement, and each one is appropriate in different circumstances. Consistency and completeness of a state are characterized in terms of the tableau associated with the state and in terms of logical properties of a set of first-order sentences associated with the state. A close relation between the problems of testing for consistency and completeness and of testing implication of dependencies is established. The possibility of formalizing dependency satisfaction without using a universal relation scheme is examined.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {177–188},
numpages = {12},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588143,
author = {Casanova, Marco A.},
title = {A Theory of Data Dependencies over Relational Expressions},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588143},
doi = {10.1145/588111.588143},
abstract = {A formal system is developed for reasoning about a class of dependencies that includes all classes considered in the literature. The usefulness of the system is illustrated by applying it to various database design problems. The system is shown to be sound and complete by adapting the analytic tableaux method of first-order predicate calculus to the class of dependencies adopted. Finally, the method is shown to be a decision procedure for the inference problem of a subclass of the dependencies considered.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {189–198},
numpages = {10},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588144,
author = {Graham, Marc H. and Yannakakis, Mihalis},
title = {Independent Database Schemas},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588144},
doi = {10.1145/588111.588144},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {199–204},
numpages = {6},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/3248289,
author = {Dobkin, David P.},
title = {Session Details: Session 8},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3248289},
doi = {10.1145/3248289},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588146,
author = {Hull, Richard and Yap, Chee K.},
title = {The Format Model: A Theory of Database Organization},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588146},
doi = {10.1145/588111.588146},
abstract = {A new theory of data representation involving "formats", which are based on three recurrent and prominent data-structuring concepts, is introduced. In a mathematically rigorous way, a notion of "equivalent" information capacity is defined and shown to be natural in a wide range of contexts. A normal form is introduced, and each equivalence class of formats is shown to have a unique representative in normal form. Finally, a natural way of comparing the information capacity of (non-equivalent) formats is formalized and studied.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {205–211},
numpages = {7},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588147,
author = {Spyratos, N.},
title = {An Operational Approach to Data Bases},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588147},
doi = {10.1145/588111.588147},
abstract = {We present a model-independent treatment of some important data base problems. Our approach uses the data base update as elementary concept. The basic tool is the data base view defined by a set of data base updates rather than by the usual view definition mapping.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {212–220},
numpages = {9},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588148,
author = {Gurevich, Yuri and Lewis, Harry R.},
title = {The Inference Problem for Template Dependencies},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588148},
doi = {10.1145/588111.588148},
abstract = {A template dependency is a formalized integrity constraint on a relational database, stating that whenever tuples exist in the database that agree on certain attributes, an additional tuple must also be present that agrees with the others in a specified way. It is here shown that the inference problem for template dependencies is undecidable, that is, there can be no algorithm for determining whether a given dependency is a logical consequence of a given finite set of dependencies. The undecidability result holds whether or not databases are considered to be necessarily finite.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {221–229},
numpages = {9},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588149,
author = {Vardi, Moshe Y.},
title = {The Implication and Finite Implication Problems for Typed Template Dependencies},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588149},
doi = {10.1145/588111.588149},
abstract = {The class of typed template dependencies is a class of data dependencies that includes embedded multivalued and join dependencies. We show that the implication and the finite implication problems for this class are unsolvable. An immediate corollary is that this class has no formal system for finite implication. We also show how to construct a finite set of typed template dependencies whose implication and finite implication problems are unsolvable.The class of simple template dependencies is a proper subclass of the above class, and it generalizes slightly embedded join dependencies. It is shown that the implication and the finite implication problems for this class are also unsolvable. An immediate corollary is that this class has no formal system for either implication or finite implication.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {230–238},
numpages = {9},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/3248290,
author = {McLeod, Dennis J.},
title = {Session Details: Session 9},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3248290},
doi = {10.1145/3248290},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588151,
author = {Maier, David},
title = {Using Write-Once Memory for Database Storage},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588151},
doi = {10.1145/588111.588151},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {239–246},
numpages = {8},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588152,
author = {Menasc\'{e}, Daniel A. and Nakanishi, Tatuo},
title = {Performance Evaluation of a Two-Phase Commit Based Protocol for DDBs},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588152},
doi = {10.1145/588111.588152},
abstract = {Many concurrency control algorithms for distributed database management systems have been proposed in the last few years, but little has been done to analyse their performance. This paper presents the specification of a concurrency control algorithm based on the two-phase commit protocol for DDBs. The results of a complete performance analysis based on an analytic model are presented and discussed.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {247–255},
numpages = {9},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588153,
author = {Gonnet, Gaston H. and Larson, Per \r{A}ke},
title = {External Hasing with Limited Internal Storage},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588153},
doi = {10.1145/588111.588153},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {256–261},
numpages = {6},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588154,
author = {Rotem, Doron and Tompa, Frank Wm. and Kirkpatrick, David},
title = {Foundations for Multifile Design by Application Partitioning},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588154},
doi = {10.1145/588111.588154},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {262–267},
numpages = {6},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/3248291,
author = {McLeod, Dennis J.},
title = {Session Details: Session 10},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3248291},
doi = {10.1145/3248291},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
numpages = {1},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588156,
author = {Manber, Udi and Ladner, Richard E.},
title = {Concurrency Control in a Dynamic Search Structure},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588156},
doi = {10.1145/588111.588156},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {268–282},
numpages = {15},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588157,
author = {Mohan, C. and Fussell, D. and Silberschatz, A.},
title = {Compatibility and Commutativity in Non-Two-Phase Locking Protocols},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588157},
doi = {10.1145/588111.588157},
abstract = {Research on concurrency control mechanisms for database systems has had as a primary goal the discovery of techniques for allowing increased levels of concurrent execution of transactions. In this paper, we study this problem in the context of non-two-phase locking protocols which are defined for data bases in which a directed acyclic graph structure is superimposed on the data items. We introduce a new lock mode, called INV, with properties fundamentally different from locking modes previously studied and show how this allows increased concurrency. Through the introduction of the INV mode of locking we have enunciated a new principle of the theory of data base concurrency control. This principle involves the separation of the effects of the commutativity and compatibility of data manipulation operations. We then examine how the introduction of such a lock mode affects the occurrence of deadlocks in a system. Certain conditions under which deadlock-freedom is maintained are identified, and simple methods for removing deadlocks in other situations are presented.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {283–292},
numpages = {10},
location = {Los Angeles, California},
series = {PODS '82}
}

@inproceedings{10.1145/588111.588158,
author = {Krishnamurthy, Ravindran and Dayal, Umeshwar},
title = {Theory of Serializablity for a Parallel Model of Transactions},
year = {1982},
isbn = {0897910702},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/588111.588158},
doi = {10.1145/588111.588158},
abstract = {In this paper we present a parallel program schema model of a transaction system and generalize the concept of serializability from the sequential two-step model to a parallel multi-step model. We define two classes of serializable executions, and for each class we discuss two problems: recognition and scheduling. It is shown that the results for the recognition and online scheduling problems for the sequential model generalize to the parallel model. But it is argued that online scheduling is not suitable for a parallel execution environment. Therefore, batch schedulers are defined and a minimal set of precedence constraints is derived. Finally, it is shown that any optimal batch scheduler that uses syntactic information alone cannot be efficient.},
booktitle = {Proceedings of the 1st ACM SIGACT-SIGMOD Symposium on Principles of Database Systems},
pages = {293–305},
numpages = {13},
location = {Los Angeles, California},
series = {PODS '82}
}

license: Unlicense

repository: goyalkaraniit/acm-cr

repo_name: goyalkaraniit/acm-cr


text:
@InProceedings{farajtabar15,
  supplementary = {Supplementary:farajtabar15-supp.pdf},
  title = {{Back to the Past: Source Identification in Diffusion Networks from Partially Observed Cascades}},
  author = {Farajtabar, Mehrdad and Gomez Rodriguez, Manuel and Zamani, Mohammad and Du, Nan and Zha, Hongyuan and Song, Le},
  pages = {232-240},
  abstract = {When a piece of malicious information becomes rampant in an information diffusion network, can we identify the source node that originally introduced the piece into the network and infer the time when it initiated this? Being able to do so is critical for curtailing the spread of malicious information, and reducing the potential losses incurred. This is a very challenging problem since typically only incomplete traces are observed and we need to unroll the incomplete traces into the past in order to pinpoint the source. In this paper, we tackle this problem by developing a two-stage framework, which first learns a continuous-time diffusion network based on historical diffusion traces and then identifies the source of an incomplete diffusion trace by maximizing the likelihood of the trace under the learned model. Experiments on both large synthetic and real-world data show that our framework can effectively go back to the past, and pinpoint the source node and its initiation time  significantly more accurately than previous state-of-the-arts.},
}

license: MIT

repository: mreid/papersite

license_type: permissive

repo_name: mreid/papersite

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: TeX

extension: bib


text:
/*
Copyright 2019 Cisco Systems

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: ciherr_nodes_bg.proto

package cisco_ios_xr_asic_errors_oper_asic_errors_nodes_node_asic_information_instances_instance_error_path_single_bit_soft_errors

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type CiherrNodesBg_KEYS struct {
	NodeName             string   `protobuf:"bytes,1,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
	Asic                 string   `protobuf:"bytes,2,opt,name=asic,proto3" json:"asic,omitempty"`
	AsicInstance         uint32   `protobuf:"varint,3,opt,name=asic_instance,json=asicInstance,proto3" json:"asic_instance,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CiherrNodesBg_KEYS) Reset()         { *m = CiherrNodesBg_KEYS{} }
func (m *CiherrNodesBg_KEYS) String() string { return proto.CompactTextString(m) }
func (*CiherrNodesBg_KEYS) ProtoMessage()    {}
func (*CiherrNodesBg_KEYS) Descriptor() ([]byte, []int) {
	return fileDescriptor_1ca32ee840cc252f, []int{0}
}

func (m *CiherrNodesBg_KEYS) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CiherrNodesBg_KEYS.Unmarshal(m, b)
}
func (m *CiherrNodesBg_KEYS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CiherrNodesBg_KEYS.Marshal(b, m, deterministic)
}
func (m *CiherrNodesBg_KEYS) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CiherrNodesBg_KEYS.Merge(m, src)
}
func (m *CiherrNodesBg_KEYS) XXX_Size() int {
	return xxx_messageInfo_CiherrNodesBg_KEYS.Size(m)
}
func (m *CiherrNodesBg_KEYS) XXX_DiscardUnknown() {
	xxx_messageInfo_CiherrNodesBg_KEYS.DiscardUnknown(m)
}

var xxx_messageInfo_CiherrNodesBg_KEYS proto.InternalMessageInfo

func (m *CiherrNodesBg_KEYS) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

func (m *CiherrNodesBg_KEYS) GetAsic() string {
	if m != nil {
		return m.Asic
	}
	return ""
}

func (m *CiherrNodesBg_KEYS) GetAsicInstance() uint32 {
	if m != nil {
		return m.AsicInstance
	}
	return 0
}

type CsrsInfoBg struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Address              uint64   `protobuf:"varint,2,opt,name=address,proto3" json:"address,omitempty"`
	Width                uint32   `protobuf:"varint,3,opt,name=width,proto3" json:"width,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CsrsInfoBg) Reset()         { *m = CsrsInfoBg{} }
func (m *CsrsInfoBg) String() string { return proto.CompactTextString(m) }
func (*CsrsInfoBg) ProtoMessage()    {}
func (*CsrsInfoBg) Descriptor() ([]byte, []int) {
	return fileDescriptor_1ca32ee840cc252f, []int{1}
}

func (m *CsrsInfoBg) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CsrsInfoBg.Unmarshal(m, b)
}
func (m *CsrsInfoBg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CsrsInfoBg.Marshal(b, m, deterministic)
}
func (m *CsrsInfoBg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CsrsInfoBg.Merge(m, src)
}
func (m *CsrsInfoBg) XXX_Size() int {
	return xxx_messageInfo_CsrsInfoBg.Size(m)
}
func (m *CsrsInfoBg) XXX_DiscardUnknown() {
	xxx_messageInfo_CsrsInfoBg.DiscardUnknown(m)
}

var xxx_messageInfo_CsrsInfoBg proto.InternalMessageInfo

func (m *CsrsInfoBg) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *CsrsInfoBg) GetAddress() uint64 {
	if m != nil {
		return m.Address
	}
	return 0
}

func (m *CsrsInfoBg) GetWidth() uint32 {
	if m != nil {
		return m.Width
	}
	return 0
}

type CiherrErrorDataBg struct {
	AtTime               uint64   `protobuf:"varint,1,opt,name=at_time,json=atTime,proto3" json:"at_time,omitempty"`
	AtTimeNsec           uint64   `protobuf:"varint,2,opt,name=at_time_nsec,json=atTimeNsec,proto3" json:"at_time_nsec,omitempty"`
	CounterVal           uint32   `protobuf:"varint,3,opt,name=counter_val,json=counterVal,proto3" json:"counter_val,omitempty"`
	ErrorRegval          []uint32 `protobuf:"varint,4,rep,packed,name=error_regval,json=errorRegval,proto3" json:"error_regval,omitempty"`
	ErrorDesc            string   `protobuf:"bytes,5,opt,name=error_desc,json=errorDesc,proto3" json:"error_desc,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CiherrErrorDataBg) Reset()         { *m = CiherrErrorDataBg{} }
func (m *CiherrErrorDataBg) String() string { return proto.CompactTextString(m) }
func (*CiherrErrorDataBg) ProtoMessage()    {}
func (*CiherrErrorDataBg) Descriptor() ([]byte, []int) {
	return fileDescriptor_1ca32ee840cc252f, []int{2}
}

func (m *CiherrErrorDataBg) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CiherrErrorDataBg.Unmarshal(m, b)
}
func (m *CiherrErrorDataBg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CiherrErrorDataBg.Marshal(b, m, deterministic)
}
func (m *CiherrErrorDataBg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CiherrErrorDataBg.Merge(m, src)
}
func (m *CiherrErrorDataBg) XXX_Size() int {
	return xxx_messageInfo_CiherrErrorDataBg.Size(m)
}
func (m *CiherrErrorDataBg) XXX_DiscardUnknown() {
	xxx_messageInfo_CiherrErrorDataBg.DiscardUnknown(m)
}

var xxx_messageInfo_CiherrErrorDataBg proto.InternalMessageInfo

func (m *CiherrErrorDataBg) GetAtTime() uint64 {
	if m != nil {
		return m.AtTime
	}
	return 0
}

func (m *CiherrErrorDataBg) GetAtTimeNsec() uint64 {
	if m != nil {
		return m.AtTimeNsec
	}
	return 0
}

func (m *CiherrErrorDataBg) GetCounterVal() uint32 {
	if m != nil {
		return m.CounterVal
	}
	return 0
}

func (m *CiherrErrorDataBg) GetErrorRegval() []uint32 {
	if m != nil {
		return m.ErrorRegval
	}
	return nil
}

func (m *CiherrErrorDataBg) GetErrorDesc() string {
	if m != nil {
		return m.ErrorDesc
	}
	return ""
}

type CiherrNodeBg struct {
	Name                 string               `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	AsicInfo             string               `protobuf:"bytes,2,opt,name=asic_info,json=asicInfo,proto3" json:"asic_info,omitempty"`
	NodeKey              uint32               `protobuf:"varint,3,opt,name=node_key,json=nodeKey,proto3" json:"node_key,omitempty"`
	AlarmOn              bool                 `protobuf:"varint,4,opt,name=alarm_on,json=alarmOn,proto3" json:"alarm_on,omitempty"`
	ThreshHi             uint32               `protobuf:"varint,5,opt,name=thresh_hi,json=threshHi,proto3" json:"thresh_hi,omitempty"`
	PeriodHi             uint32               `protobuf:"varint,6,opt,name=period_hi,json=periodHi,proto3" json:"period_hi,omitempty"`
	ThreshLo             uint32               `protobuf:"varint,7,opt,name=thresh_lo,json=threshLo,proto3" json:"thresh_lo,omitempty"`
	PeriodLo             uint32               `protobuf:"varint,8,opt,name=period_lo,json=periodLo,proto3" json:"period_lo,omitempty"`
	Count                uint32               `protobuf:"varint,9,opt,name=count,proto3" json:"count,omitempty"`
	IntrType             uint32               `protobuf:"varint,10,opt,name=intr_type,json=intrType,proto3" json:"intr_type,omitempty"`
	LeafId               uint32               `protobuf:"varint,11,opt,name=leaf_id,json=leafId,proto3" json:"leaf_id,omitempty"`
	LastCleared          uint64               `protobuf:"varint,12,opt,name=last_cleared,json=lastCleared,proto3" json:"last_cleared,omitempty"`
	CsrsInfo             []*CsrsInfoBg        `protobuf:"bytes,13,rep,name=csrs_info,json=csrsInfo,proto3" json:"csrs_info,omitempty"`
	LastErr              []*CiherrErrorDataBg `protobuf:"bytes,14,rep,name=last_err,json=lastErr,proto3" json:"last_err,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *CiherrNodeBg) Reset()         { *m = CiherrNodeBg{} }
func (m *CiherrNodeBg) String() string { return proto.CompactTextString(m) }
func (*CiherrNodeBg) ProtoMessage()    {}
func (*CiherrNodeBg) Descriptor() ([]byte, []int) {
	return fileDescriptor_1ca32ee840cc252f, []int{3}
}

func (m *CiherrNodeBg) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CiherrNodeBg.Unmarshal(m, b)
}
func (m *CiherrNodeBg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CiherrNodeBg.Marshal(b, m, deterministic)
}
func (m *CiherrNodeBg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CiherrNodeBg.Merge(m, src)
}
func (m *CiherrNodeBg) XXX_Size() int {
	return xxx_messageInfo_CiherrNodeBg.Size(m)
}
func (m *CiherrNodeBg) XXX_DiscardUnknown() {
	xxx_messageInfo_CiherrNodeBg.DiscardUnknown(m)
}

var xxx_messageInfo_CiherrNodeBg proto.InternalMessageInfo

func (m *CiherrNodeBg) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *CiherrNodeBg) GetAsicInfo() string {
	if m != nil {
		return m.AsicInfo
	}
	return ""
}

func (m *CiherrNodeBg) GetNodeKey() uint32 {
	if m != nil {
		return m.NodeKey
	}
	return 0
}

func (m *CiherrNodeBg) GetAlarmOn() bool {
	if m != nil {
		return m.AlarmOn
	}
	return false
}

func (m *CiherrNodeBg) GetThreshHi() uint32 {
	if m != nil {
		return m.ThreshHi
	}
	return 0
}

func (m *CiherrNodeBg) GetPeriodHi() uint32 {
	if m != nil {
		return m.PeriodHi
	}
	return 0
}

func (m *CiherrNodeBg) GetThreshLo() uint32 {
	if m != nil {
		return m.ThreshLo
	}
	return 0
}

func (m *CiherrNodeBg) GetPeriodLo() uint32 {
	if m != nil {
		return m.PeriodLo
	}
	return 0
}

func (m *CiherrNodeBg) GetCount() uint32 {
	if m != nil {
		return m.Count
	}
	return 0
}

func (m *CiherrNodeBg) GetIntrType() uint32 {
	if m != nil {
		return m.IntrType
	}
	return 0
}

func (m *CiherrNodeBg) GetLeafId() uint32 {
	if m != nil {
		return m.LeafId
	}
	return 0
}

func (m *CiherrNodeBg) GetLastCleared() uint64 {
	if m != nil {
		return m.LastCleared
	}
	return 0
}

func (m *CiherrNodeBg) GetCsrsInfo() []*CsrsInfoBg {
	if m != nil {
		return m.CsrsInfo
	}
	return nil
}

func (m *CiherrNodeBg) GetLastErr() []*CiherrErrorDataBg {
	if m != nil {
		return m.LastErr
	}
	return nil
}

type CiherrNodesBg struct {
	Error                []*CiherrNodeBg `protobuf:"bytes,50,rep,name=error,proto3" json:"error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *CiherrNodesBg) Reset()         { *m = CiherrNodesBg{} }
func (m *CiherrNodesBg) String() string { return proto.CompactTextString(m) }
func (*CiherrNodesBg) ProtoMessage()    {}
func (*CiherrNodesBg) Descriptor() ([]byte, []int) {
	return fileDescriptor_1ca32ee840cc252f, []int{4}
}

func (m *CiherrNodesBg) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CiherrNodesBg.Unmarshal(m, b)
}
func (m *CiherrNodesBg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CiherrNodesBg.Marshal(b, m, deterministic)
}
func (m *CiherrNodesBg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CiherrNodesBg.Merge(m, src)
}
func (m *CiherrNodesBg) XXX_Size() int {
	return xxx_messageInfo_CiherrNodesBg.Size(m)
}
func (m *CiherrNodesBg) XXX_DiscardUnknown() {
	xxx_messageInfo_CiherrNodesBg.DiscardUnknown(m)
}

var xxx_messageInfo_CiherrNodesBg proto.InternalMessageInfo

func (m *CiherrNodesBg) GetError() []*CiherrNodeBg {
	if m != nil {
		return m.Error
	}
	return nil
}

func init() {
	proto.RegisterType((*CiherrNodesBg_KEYS)(nil), "cisco_ios_xr_asic_errors_oper.asic_errors.nodes.node.asic_information.instances.instance.error_path.single_bit_soft_errors.ciherr_nodes_bg_KEYS")
	proto.RegisterType((*CsrsInfoBg)(nil), "cisco_ios_xr_asic_errors_oper.asic_errors.nodes.node.asic_information.instances.instance.error_path.single_bit_soft_errors.csrs_info_bg")
	proto.RegisterType((*CiherrErrorDataBg)(nil), "cisco_ios_xr_asic_errors_oper.asic_errors.nodes.node.asic_information.instances.instance.error_path.single_bit_soft_errors.ciherr_error_data_bg")
	proto.RegisterType((*CiherrNodeBg)(nil), "cisco_ios_xr_asic_errors_oper.asic_errors.nodes.node.asic_information.instances.instance.error_path.single_bit_soft_errors.ciherr_node_bg")
	proto.RegisterType((*CiherrNodesBg)(nil), "cisco_ios_xr_asic_errors_oper.asic_errors.nodes.node.asic_information.instances.instance.error_path.single_bit_soft_errors.ciherr_nodes_bg")
}

func init() { proto.RegisterFile("ciherr_nodes_bg.proto", fileDescriptor_1ca32ee840cc252f) }

var fileDescriptor_1ca32ee840cc252f = []byte{
	// 582 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x94, 0xcf, 0x8e, 0xd3, 0x3e,
	0x10, 0xc7, 0x95, 0x5f, 0xff, 0xa5, 0xd3, 0x76, 0x7f, 0x92, 0xb5, 0x08, 0xa3, 0x15, 0xa2, 0x94,
	0x4b, 0x4f, 0x39, 0x2c, 0x8f, 0x00, 0x2b, 0xb1, 0xda, 0xd5, 0x22, 0x85, 0x15, 0x12, 0x27, 0xcb,
	0x4d, 0xa6, 0xad, 0x45, 0x6a, 0x47, 0xb6, 0xf9, 0x53, 0x9e, 0x00, 0x71, 0xe2, 0x15, 0xb8, 0x70,
	0xe2, 0x84, 0xe0, 0xfd, 0x90, 0xc7, 0xa6, 0x8a, 0x56, 0x70, 0x5e, 0x2e, 0x91, 0xe7, 0x33, 0x99,
	0x99, 0xef, 0xcc, 0xc4, 0x81, 0x3b, 0x95, 0xda, 0xa2, 0xb5, 0x42, 0x9b, 0x1a, 0x9d, 0x58, 0x6d,
	0x8a, 0xd6, 0x1a, 0x6f, 0xd8, 0x87, 0x4a, 0xb9, 0xca, 0x08, 0x65, 0x9c, 0x78, 0x6f, 0x85, 0x74,
	0xaa, 0x12, 0x68, 0xad, 0xb1, 0x4e, 0x98, 0x16, 0x6d, 0xd1, 0x01, 0x05, 0x45, 0xd2, 0x33, 0x62,
	0xa5, 0xd7, 0xc6, 0xee, 0xa4, 0x57, 0x46, 0x17, 0x4a, 0x3b, 0x2f, 0x75, 0x85, 0xee, 0x70, 0x2a,
	0x28, 0x4a, 0xb4, 0xd2, 0x6f, 0x0b, 0xa7, 0xf4, 0xa6, 0x41, 0xb1, 0x52, 0x5e, 0x38, 0xb3, 0xf6,
	0x29, 0xe1, 0xa2, 0x81, 0xe3, 0x1b, 0xa2, 0xc4, 0xc5, 0xd9, 0xab, 0x17, 0xec, 0x04, 0xc6, 0x01,
	0x08, 0x2d, 0x77, 0xc8, 0xb3, 0x79, 0xb6, 0x1c, 0x97, 0x79, 0x00, 0x57, 0x72, 0x87, 0x8c, 0x41,
	0x3f, 0x54, 0xe7, 0xff, 0x11, 0xa7, 0x33, 0x7b, 0x04, 0xb3, 0xa4, 0x28, 0xd6, 0xe6, 0xbd, 0x79,
	0xb6, 0x9c, 0x95, 0xd3, 0x00, 0xcf, 0x13, 0x5b, 0x94, 0x30, 0xad, 0x9c, 0x75, 0x24, 0x5b, 0xac,
	0x36, 0x21, 0x51, 0xa7, 0x00, 0x9d, 0x19, 0x87, 0x91, 0xac, 0x6b, 0x8b, 0xce, 0x51, 0xfe, 0x7e,
	0xf9, 0xdb, 0x64, 0xc7, 0x30, 0x78, 0xa7, 0x6a, 0xbf, 0x4d, 0xa9, 0xa3, 0xb1, 0xf8, 0x91, 0x1d,
	0x5a, 0x88, 0xed, 0xd6, 0xd2, 0xcb, 0x90, 0xfc, 0x2e, 0x8c, 0xa4, 0x17, 0x5e, 0xa5, 0xfc, 0xfd,
	0x72, 0x28, 0xfd, 0xb5, 0xda, 0x21, 0x9b, 0xc3, 0x34, 0x39, 0x84, 0x76, 0x58, 0xa5, 0x32, 0x10,
	0xbd, 0x57, 0x0e, 0x2b, 0xf6, 0x00, 0x26, 0x95, 0x79, 0xa3, 0x3d, 0x5a, 0xf1, 0x56, 0x36, 0xa9,
	0x1e, 0x24, 0xf4, 0x52, 0x36, 0xec, 0x21, 0x4c, 0x63, 0x31, 0x8b, 0x9b, 0xf0, 0x46, 0x7f, 0xde,
	0x5b, 0xce, 0xca, 0x09, 0xb1, 0x92, 0x10, 0xbb, 0x0f, 0x90, 0xf4, 0xa0, 0xab, 0xf8, 0x80, 0x3a,
	0x1c, 0x13, 0x79, 0x8a, 0xae, 0x5a, 0x7c, 0x1f, 0xc0, 0x51, 0x67, 0xf2, 0x7f, 0x9b, 0xc6, 0x09,
	0x8c, 0x0f, 0x8b, 0x4e, 0xf3, 0xce, 0xe3, 0x48, 0xd7, 0x86, 0xdd, 0x03, 0xda, 0x89, 0x78, 0x8d,
	0xfb, 0xa4, 0x71, 0x14, 0xec, 0x0b, 0xdc, 0x07, 0x97, 0x6c, 0xa4, 0xdd, 0x09, 0xa3, 0x79, 0x7f,
	0x9e, 0x2d, 0xf3, 0x72, 0x44, 0xf6, 0x73, 0x1d, 0x52, 0xfa, 0xad, 0x45, 0xb7, 0x15, 0x5b, 0x45,
	0xba, 0x66, 0x65, 0x1e, 0xc1, 0x33, 0x15, 0x9c, 0x2d, 0x5a, 0x65, 0xea, 0xe0, 0x1c, 0x46, 0x67,
	0x04, 0xd1, 0x99, 0x22, 0x1b, 0xc3, 0x47, 0xdd, 0xc8, 0x4b, 0xd3, 0x89, 0x6c, 0x0c, 0xcf, 0xbb,
	0x91, 0x97, 0x26, 0xac, 0x8e, 0xa6, 0xc7, 0xc7, 0x71, 0x75, 0x64, 0x84, 0x10, 0xa5, 0xbd, 0x15,
	0x7e, 0xdf, 0x22, 0x87, 0x18, 0x12, 0xc0, 0xf5, 0xbe, 0xc5, 0xb0, 0xbe, 0x06, 0xe5, 0x5a, 0xa8,
	0x9a, 0x4f, 0xc8, 0x35, 0x0c, 0xe6, 0x79, 0x1d, 0x66, 0xdf, 0x48, 0xe7, 0x45, 0xd5, 0xa0, 0xb4,
	0x58, 0xf3, 0x29, 0xad, 0x6f, 0x12, 0xd8, 0x93, 0x88, 0xd8, 0xd7, 0x0c, 0xc6, 0x87, 0x0f, 0x8d,
	0xcf, 0xe6, 0xbd, 0xe5, 0xe4, 0xf4, 0x63, 0x56, 0xdc, 0xde, 0x3d, 0x2b, 0xba, 0x9f, 0x7d, 0x99,
	0x07, 0x8b, 0x36, 0xf8, 0x2d, 0x83, 0x9c, 0x9a, 0x41, 0x6b, 0xf9, 0x11, 0xe9, 0xfc, 0x7c, 0xbb,
	0x3a, 0xff, 0x70, 0x93, 0xca, 0x51, 0x90, 0x78, 0x66, 0xed, 0xe2, 0x67, 0x06, 0xff, 0xdf, 0xf8,
	0x5d, 0xb0, 0x2f, 0x19, 0x0c, 0xe8, 0x75, 0x7e, 0x4a, 0xfa, 0x3f, 0xfd, 0x0b, 0xfa, 0xd3, 0x95,
	0x2a, 0xa3, 0xb2, 0xd5, 0x90, 0x7e, 0xb4, 0x8f, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x11, 0x0a,
	0x57, 0x55, 0x81, 0x05, 0x00, 0x00,
}

repository: cisco-ie/cisco-proto

repo_name: cisco-ie/cisco-proto

gha_language: Go

extension: go


text:
# only cmake since 3.13 supports packaging of debuginfo
cmake_minimum_required ( VERSION 3.17 )

SET ( CPACK_PACKAGING_INSTALL_PREFIX "/usr" )

# Common debian-specific build variables
set ( CPACK_GENERATOR DEB )
set ( CPACK_DEBIAN_FILE_NAME DEB-DEFAULT )
set ( CPACK_DEB_COMPONENT_INSTALL ON )
set ( CPACK_DEBIAN_MODULE_DEBUGINFO_PACKAGE ON )

set ( CPACK_DEBIAN_PACKAGE_PRIORITY optional )

set ( CPACK_DEBIAN_DEV_PACKAGE_ARCHITECTURE all)
set ( CPACK_DEBIAN_DEV_PACKAGE_RECOMMENDS manticore-columnar-lib )
set ( CPACK_DEBIAN_DEV_PACKAGE_SECTION devel )
set ( CPACK_DEBIAN_DEV_DESCRIPTION "This package includes headers and cmake project for manticore columnar library" )

# dependencies will be auto calculated. FIXME! M.b. point them directly?
set ( CPACK_DEBIAN_MODULE_PACKAGE_NAME ${CPACK_PACKAGE_NAME} )
set ( CPACK_DEBIAN_MODULE_PACKAGE_RECOMMENDS "manticore (>= 3.6.1)" )
set ( CPACK_DEBIAN_MODULE_PACKAGE_SHLIBDEPS ON )
set ( CPACK_DEBIAN_MODULE_PACKAGE_SECTION misc )
set ( CPACK_DEBIAN_MODULE_PACKAGE_CONTROL_STRICT_PERMISSION ON )

# just output tons of diagnostic info at the end of generation
set ( CPACK_DEBIAN_PACKAGE_DEBUG ON )

repository: tozhu/columnar

repo_name: tozhu/columnar

extension: cmake


text:
@preamble{ " \newcommand{\noop}[1]{} " }
@techreport{tbep0216,
	author={{M. Wessel, K. Dixon}},
	year={2016},
	title={{Southwest Florida Tidal Creeks Nutrient Study}},
	number={02-16},
	publisher={Tampa Bay Estuary Program},
	address={St. Petersburg, Florida},
	pages={},
	misc={},
	url={https://drive.google.com/file/d/1YeaZUqIFiak8KdJLSqNrCsQETf8_XTzZ/view?usp=drivesdk},
}
@techreport{tbep0220,
	author={{Janicki Environmental and Mote Marine Laboratory}},
	year={2020},
	title={{Southwest Florida Tidal Creeks: Nutrient Management Framework and Indicator Development}},
	number={02-20},
	publisher={Tampa Bay Estuary Program},
	address={St. Petersburg, Florida},
	pages={},
	misc={},
	url={https://drive.google.com/file/d/1n4okSVtNSswVXv1Lje-qMopNZdvUrQnt/view?usp=drivesdk},
}
@article{tbep1121,
	author={{M.R. Wessel, J.R. Leverone, M.W. Beck, E.T. Sherwood, J. Hecker, S. West, A. Janicki}},
	year={2022},
	title={{Developing a water quality assessment framework for southwest Florida tidal creeks}},
	journal={Estuaries & Coasts},
	volume={45},
	number={},
	pages={17-37},
	doi={https://doi.org/10.1007/s12237-021-00974-7},
	misc={},
	url={https://doi.org/10.1007/s12237-021-00974-7},
}

repository: tbep-tech/tbeptools

repo_name: tbep-tech/tbeptools

gha_license_id: NOASSERTION

gha_language: R


text:
require linux.inc

DEPENDS += "openssl-native"

DESCRIPTION = "Linux kernel"
KERNEL_IMAGETYPE ?= "zImage"

COMPATIBLE_MACHINE = "(rogue|dominion-old|beast|macbook|soekris-net6501|arietta-g25|macbook|minnow|minnowboard|fri2|beaglebone|apu2c4|revo|dlink-dns320)"

FILESPATH =. "${FILE_DIRNAME}/linux-dominion-4.11:${FILE_DIRNAME}/linux-dominion-4.11/${MACHINE}:"

S = "${WORKDIR}/git"

PV = "4.11.8"

SRC_URI = "git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git;branch=linux-4.11.y"
SRCREV_pn-${PN} = "8afcfa55e6a7d8c58bdb4355bd544602e6f0c3ad"

SRC_URI += " \
             file://0001-wireless-populate-db.txt.patch \
             file://0001-bonding-sane-default-value-for-MAX_BONDS.patch \
             file://0002-block-cgroups-kconfig-build-bits-for-BFQ-v7r11-4.11..patch \
             file://0003-block-introduce-the-BFQ-v7r11-I-O-sched-for-4.11.0.patch \
             file://0004-block-bfq-add-Early-Queue-Merge-EQM-to-BFQ-v7r11-for.patch \
             file://0005-blk-bfq-turn-BFQ-v7r11-for-4.11.0-into-BFQ-v8r11-for.patch \
             file://am335x-pm-firmware.elf \
             file://defconfig \
             file://bbr.fragment \
             file://bfq.fragment \
             file://intel.fragment \
             file://block.fragment \
             file://btrfs.fragment \
             file://debug.fragment \
             file://systemd.fragment \
             file://mlx.fragment \
            "

KERNEL_CONFIG_FRAGMENTS_append = " \
                                  ${WORKDIR}/bbr.fragment \
                                  ${WORKDIR}/bfq.fragment \
                                  ${WORKDIR}/block.fragment \
                                  ${WORKDIR}/btrfs.fragment \
                                  ${WORKDIR}/debug.fragment \
                                 "

KERNEL_CONFIG_FRAGMENTS_append_x86 = " \
                                  ${WORKDIR}/intel.fragment \
                                 "

KERNEL_CONFIG_FRAGMENTS_append_x86_64 = " \
                                  ${WORKDIR}/intel.fragment \
                                 "

KERNEL_CONFIG_FRAGMENTS_append_dominion = " \
                                  ${WORKDIR}/mlx.fragment \
                                 "

KERNEL_CONFIG_FRAGMENTS_append_beast = " \
                                  ${WORKDIR}/mlx.fragment \
                                 "

KERNEL_CONFIG_FRAGMENTS_append_rogue = " \
                                  ${WORKDIR}/mlx.fragment \
                                 "

do_configure_prepend() {
	if [ -e ${WORKDIR}/am335x-pm-firmware.elf ] ; then
		cp ${WORKDIR}/am335x-pm-firmware.elf ${S}/firmware/
	fi
}

repository: sivaraml/meta-dominion

repo_name: sivaraml/meta-dominion

extension: bb


text:
@Article{aliNron,
	title = {Patterns and Intensity of Use of Homeless Shelters in Toronto},
	author = {Ali Jadidzadeh and Ron KneeBone},
	year = {2018},
	journal = {Canadian Public Policy},
	volume = {44},
	number = {4},
	pages = {342-355},
	doi = {10.3138/cpp.2018-013}
}

@Dataset{dataset,
  title = {Daily Shelter Occupancy},
  organization = {Shelter, Support & Housing Administration},
  year = {2021},
  url = {https://open.toronto.ca/dataset/daily-shelter-occupancy/}
}

@Website{TorontoCity,
  title = {Shelter, Support & Houding Administration},
  organization = {City of Toronto},
  year = {2019},
  url = {https://www.toronto.ca/city-government/accountability-operations-customer-service/city-administration/staff-directory-divisions-and-customer-service/shelter-support-housing-administration/}
}

@Manual{citeR,
  title = {R: A Language and Environment for Statistical Computing},
  author = {{R Core Team}},
  organization = {R Foundation for Statistical Computing},
  address = {Vienna, Austria},
  year = {2020},
  url = {https://www.R-project.org/}
}

@Article{tidy,
  title = {Welcome to the {tidyverse}},
  author = {Hadley Wickham and Mara Averick and Jennifer Bryan and Winston Chang and Lucy D'Agostino McGowan and Romain François and Garrett Grolemund and Alex Hayes and Lionel Henry and Jim Hester and Max Kuhn and Thomas Lin Pedersen and Evan Miller and Stephan Milton Bache and Kirill Müller and Jeroen Ooms and David Robinson and Dana Paige Seidel and Vitalie Spinu and Kohske Takahashi and Davis Vaughan and Claus Wilke and Kara Woo and Hiroaki Yutani},
  year = {2019},
  journal = {Journal of Open Source Software},
  volume = {4},
  number = {43},
  pages = {1686},
  doi = {10.21105/joss.01686},
}

@Book{gg,
    author = {Hadley Wickham},
    title = {ggplot2: Elegant Graphics for Data Analysis},
    publisher = {Springer-Verlag New York},
    year = {2016},
    isbn = {978-3-319-24277-4},
    url = {https://ggplot2.tidyverse.org},
  }

@Manual{openDataToronto,
  title = {opendatatoronto: Access the City of Toronto Open Data Portal},
  author = {Sharla Gelfand},
  year = {2020},
  note = {R package version 0.1.4},
  url = {https://CRAN.R-project.org/package=opendatatoronto},
}

@Manual{janitor,
    title = {janitor: Simple Tools for Examining and Cleaning Dirty Data},
    author = {Sam Firke},
    year = {2021},
    note = {R package version 2.1.0},
    url = {https://CRAN.R-project.org/package=janitor},
  }

@misc{alexander2021shelter,
  author = {Alexander, Rohan},
  title = {Rohan Alexander: Shelter usage in Toronto (2017-2021)},
  url = {https://rohanalexander.com/posts/2021-01-24-shelter-usage-in-toronto-2017-2021/},
  year = {2021}
}

@Website{TorontoShelters,
  title = {Daily Shelter & Overnight Service Usage},
  organization = {City of Toronto},
  year = {2021},
  url = {https://www.toronto.ca/city-government/data-research-maps/research-reports/housing-and-homelessness-research-and-reports/shelter-census/}
}

@Manual{dplyr,
    title = {dplyr: A Grammar of Data Manipulation},
    author = {Hadley Wickham and Romain François and Lionel Henry and Kirill Müller},
    year = {2021},
    note = {R package version 1.0.3},
    url = {https://CRAN.R-project.org/package=dplyr},
  }

@Article{lubr,
    title = {Dates and Times Made Easy with {lubridate}},
    author = {Garrett Grolemund and Hadley Wickham},
    journal = {Journal of Statistical Software},
    year = {2011},
    volume = {40},
    number = {3},
    pages = {1--25},
    url = {https://www.jstatsoft.org/v40/i03/},
  }

branch_name: refs/heads/main


text:
package configuration

import (
	"errors"
	"github.com/COSAE-FR/riputils/pfsense/configuration/sections"
)

type InterfaceGetter interface {
	GetInterface(pfSenseInterface string) *sections.Interface
	GetPhysicalInterfaceName(pfSenseInterface string) (string, error)
}

func (c BaseConfiguration) GetInterface(pfSenseInterface string) *sections.Interface {
	config, ok := c.Interfaces[pfSenseInterface]
	if ok {
		return &config
	}
	return nil
}

func (c BaseConfiguration) GetPhysicalInterfaceName(pfSenseInterface string) (string, error) {
	config := c.GetInterface(pfSenseInterface)
	if config == nil {
		return "", errors.New("not found")
	}
	if len(config.If) == 0 {
		return "", errors.New("no physical interface")
	}
	return config.If, nil
}

repository: COSAE-FR/riputils

repo_name: COSAE-FR/riputils


text:
/*
Copyright 2019 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package cluster

import (
	"fmt"
	"net"
	"strconv"

	"github.com/pkg/errors"

	apiv1 "k8s.io/api/core/v1"
	apierrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
	"k8s.io/klog/klogr"
	clusterv1 "sigs.k8s.io/cluster-api/pkg/apis/cluster/v1alpha1"
	clientv1 "sigs.k8s.io/cluster-api/pkg/client/clientset_generated/clientset/typed/cluster/v1alpha1"
	clusterErr "sigs.k8s.io/cluster-api/pkg/controller/error"

	"sigs.k8s.io/cluster-api-provider-vsphere/pkg/cloud/vsphere/actuators"
	"sigs.k8s.io/cluster-api-provider-vsphere/pkg/cloud/vsphere/constants"
	"sigs.k8s.io/cluster-api-provider-vsphere/pkg/cloud/vsphere/context"
	"sigs.k8s.io/cluster-api-provider-vsphere/pkg/cloud/vsphere/services/certificates"
	"sigs.k8s.io/cluster-api-provider-vsphere/pkg/cloud/vsphere/services/kubeclient"
)

// Actuator is responsible for maintaining the Cluster objects.
type Actuator struct {
	client     clientv1.ClusterV1alpha1Interface
	coreClient corev1.CoreV1Interface
}

// NewActuator returns a new instance of Actuator.
func NewActuator(
	client clientv1.ClusterV1alpha1Interface,
	coreClient corev1.CoreV1Interface) *Actuator {

	return &Actuator{
		client:     client,
		coreClient: coreClient,
	}
}

// Reconcile will create or update the cluster
func (a *Actuator) Reconcile(cluster *clusterv1.Cluster) (opErr error) {
	ctx, err := context.NewClusterContext(&context.ClusterContextParams{
		Cluster:    cluster,
		Client:     a.client,
		CoreClient: a.coreClient,
		Logger:     klogr.New().WithName("[cluster-actuator]"),
	})
	if err != nil {
		return err
	}

	defer func() {
		opErr = actuators.PatchAndHandleError(ctx, "Reconcile", opErr)
	}()

	ctx.Logger.V(6).Info("reconciling cluster")

	if err := a.reconcilePKI(ctx); err != nil {
		return err
	}

	if err := a.reconcileReadyState(ctx); err != nil {
		return err
	}

	// reconcileKubeConfig can fail because control plane endpoints
	// aren't ready so return requeue error
	if err := a.reconcileKubeConfig(ctx); err != nil {
		return errors.Wrapf(&clusterErr.RequeueAfterError{RequeueAfter: constants.DefaultRequeue},
			"error reconciling kubeconfig secret for cluster %q", ctx)
	}

	return nil
}

// Delete will delete any cluster level resources for the cluster.
func (a *Actuator) Delete(cluster *clusterv1.Cluster) (opErr error) {
	ctx, err := context.NewClusterContext(&context.ClusterContextParams{
		Cluster:    cluster,
		Client:     a.client,
		CoreClient: a.coreClient,
	})
	if err != nil {
		return err
	}

	defer func() {
		opErr = actuators.PatchAndHandleError(ctx, "Delete", opErr)
	}()

	ctx.Logger.V(2).Info("deleting cluster")

	// if deleteKubeconfig fails, return requeue error so kubeconfig
	// secret is properly cleaned up
	if err := a.deleteKubeConfig(ctx); err != nil {
		return errors.Wrapf(&clusterErr.RequeueAfterError{RequeueAfter: constants.DefaultRequeue},
			"error deleting kubeconfig secret for cluster %q", ctx)
	}

	return nil
}

// GetIP returns the control plane endpoint for the cluster.
func (a *Actuator) GetIP(cluster *clusterv1.Cluster, machine *clusterv1.Machine) (string, error) {
	clusterContext, err := context.NewClusterContext(&context.ClusterContextParams{
		Cluster:    cluster,
		Client:     a.client,
		CoreClient: a.coreClient,
	})
	if err != nil {
		return "", err
	}
	machineContext, err := context.NewMachineContextFromClusterContext(clusterContext, machine)
	if err != nil {
		return "", err
	}
	return machineContext.ControlPlaneEndpoint()
}

// GetKubeConfig returns the contents of a Kubernetes configuration file that
// may be used to access the cluster.
func (a *Actuator) GetKubeConfig(cluster *clusterv1.Cluster, machine *clusterv1.Machine) (string, error) {
	clusterContext, err := context.NewClusterContext(&context.ClusterContextParams{
		Cluster:    cluster,
		Client:     a.client,
		CoreClient: a.coreClient,
	})
	if err != nil {
		return "", err
	}

	if machine == nil {
		return kubeclient.GetKubeConfig(clusterContext)
	}

	machineContext, err := context.NewMachineContextFromClusterContext(clusterContext, machine)
	if err != nil {
		return "", err
	}

	return kubeclient.GetKubeConfig(machineContext)
}

func (a *Actuator) reconcilePKI(ctx *context.ClusterContext) error {
	if err := certificates.ReconcileCertificates(ctx); err != nil {
		return errors.Wrapf(err, "unable to reconcile certs while reconciling cluster %q", ctx)
	}
	return nil
}

func (a *Actuator) reconcileReadyState(ctx *context.ClusterContext) error {
	online, controlPlaneEndpoint, err := kubeclient.GetControlPlaneStatus(ctx)
	if err != nil {
		// This may or may not contain RequeueError. If it does then the deferred
		// PathAndHandleError will take care of requeueing things.
		return err
	}
	if !online {
		return &clusterErr.RequeueAfterError{RequeueAfter: constants.DefaultRequeue}
	}
	host, szPort, err := net.SplitHostPort(controlPlaneEndpoint)
	if err != nil {
		return errors.Wrapf(err, "unable to get host/port for control plane endpoint %q for %q", controlPlaneEndpoint, ctx)
	}
	port, err := strconv.Atoi(szPort)
	if err != nil {
		return errors.Wrapf(err, "unable to get parse host and port for control plane endpoint %q for %q", controlPlaneEndpoint, ctx)
	}
	if len(ctx.Cluster.Status.APIEndpoints) == 0 || (ctx.Cluster.Status.APIEndpoints[0].Host != host && ctx.Cluster.Status.APIEndpoints[0].Port != port) {
		ctx.Cluster.Status.APIEndpoints = []clusterv1.APIEndpoint{
			{
				Host: host,
				Port: port,
			},
		}
	}
	if ctx.ClusterConfig.ClusterConfiguration.ControlPlaneEndpoint == "" {
		ctx.ClusterConfig.ClusterConfiguration.ControlPlaneEndpoint = controlPlaneEndpoint
		ctx.Logger.V(6).Info("stored control plane endpoint in kubeadm cluster config", "control-plane-endpoint", controlPlaneEndpoint)
	}
	ctx.ClusterStatus.Ready = true
	if ctx.Cluster.Annotations == nil {
		ctx.Cluster.Annotations = map[string]string{}
	}
	ctx.Cluster.Annotations[constants.ReadyAnnotationLabel] = "true"
	ctx.Logger.V(6).Info("cluster is ready")

	return nil
}

// reconcileKubeConfig creates a Kubernetes Secret holding the kubeconfig
// for a cluster if the secret does not already exist
func (a *Actuator) reconcileKubeConfig(ctx *context.ClusterContext) error {
	cluster := ctx.Cluster

	kubeConfig, err := a.GetKubeConfig(cluster, nil)
	if err != nil {
		return errors.Wrap(err, "error generating kubeconfig")
	}

	secret := &apiv1.Secret{
		ObjectMeta: metav1.ObjectMeta{
			Name: fmt.Sprintf("%s-kubeconfig", cluster.Name),
		},
		StringData: map[string]string{
			"value": kubeConfig,
		},
	}

	if _, err := a.coreClient.Secrets(cluster.Namespace).Create(secret); err != nil &&
		!apierrors.IsAlreadyExists(err) {
		return errors.Wrap(err, "error creating kubeconfig secret")
	}

	return nil
}

func (a *Actuator) deleteKubeConfig(ctx *context.ClusterContext) error {
	secretName := fmt.Sprintf("%s-kubeconfig", ctx.Cluster.Name)

	err := a.coreClient.Secrets(ctx.Cluster.Namespace).Delete(secretName, &metav1.DeleteOptions{})
	if apierrors.IsNotFound(err) {
		return nil
	}

	return err
}

repository: yktsubo/cluster-api-provider-vsphere

repo_name: yktsubo/cluster-api-provider-vsphere