myer 0.0.1

data/lib/myer/cli_controller.rb

@@ -0,0 +1,204 @@
+class CliController
+  include Myer::Config
+
+  attr_accessor :out, :crypto
+
+  def initialize
+    @out = STDOUT
+    initialize_config
+    @crypto = Crypto.new
+  end
+
+  def api(server_name = default_server)
+    api = MySelf::Api.new
+    api.server = server_name
+    if server(server_name)
+      api.user = server(server_name).user_id
+      api.password = server(server_name).user_password
+    end
+    api
+  end
+
+  def create_bucket(name)
+    read_config
+
+    bucket_id = api.create_bucket
+
+    self.default_bucket_id = bucket_id
+
+    ticket = Ticket.new
+    ticket.server = default_server
+    ticket.bucket_id = bucket_id
+    ticket.key = @crypto.generate_passphrase
+    ticket.name = name
+
+    store = TicketStore.new(config_dir)
+    store.save_ticket(ticket)
+
+    write_config
+
+    out.puts("Created new bucket and stored its secret ticket at #{store.ticket_path(ticket)}.")
+    out.puts("You need this ticket to give other clients access to the bucket.")
+    out.puts("Keep it safe and secret. Everybody who has the ticket can read the bucket data.")
+
+    bucket_id
+  end
+
+  def create_token
+    read_config
+
+    token = api.create_token
+
+    out.puts("Created token: #{token}")
+    out.puts("Use this token to register another client, " +
+             "e.g. with `myer register #{default_server} #{token}`.")
+
+    token
+  end
+
+  def register(server_name, token)
+    read_config
+
+    self.default_server = server_name
+    self.user_id, self.user_password = api(server_name).register(token)
+
+    write_config
+  end
+
+  def write_item(bucket_id, content)
+    read_config
+
+    return api.create_item(bucket_id, content)
+  end
+
+  def write_raw(content)
+    read_config
+    write_item(default_bucket_id, content)
+  end
+
+  def write(content)
+    read_config
+
+    store = TicketStore.new(config_dir)
+    ticket = store.load_ticket(default_bucket_id)
+
+    @crypto.passphrase = ticket.key
+
+    encrypted_content = @crypto.encrypt(content)
+
+    write_item(default_bucket_id, encrypted_content)
+  end
+
+  def read_items(bucket_id)
+    read_config
+
+    store = TicketStore.new(config_dir)
+    ticket = store.load_ticket(default_bucket_id)
+
+    @crypto.passphrase = ticket.key
+
+    items = api.get_items(bucket_id)
+
+    content_list = []
+    items.each do |item|
+      content = @crypto.decrypt(item.content)
+      out.puts("#{item.id}: #{content}")
+      content_list.push(content)
+    end
+
+    content_list
+  end
+
+  def read
+    read_config
+    if !default_bucket_id || default_bucket_id.empty?
+      raise Myer::Error.new("Default bucket id not set")
+    end
+    inner_items = read_items(default_bucket_id)
+
+    FileUtils.mkdir_p(data_dir)
+    csv_file = local_csv_path(default_bucket_id)
+    content = Content.new
+
+    inner_items.each do |inner_item|
+      content.add(inner_item)
+    end
+
+    content.write_as_csv(csv_file)
+
+    inner_items
+  end
+
+  def create_payload(value, tag = nil)
+    payload = {}
+    payload["id"] = SecureRandom.hex
+    payload["written_at"] = Time.now.utc.strftime("%FT%TZ")
+    payload["tag"] = tag if tag
+    payload["data"] = value.to_s
+    JSON.generate(payload)
+  end
+
+  def write_value(value, tag = nil)
+    write(create_payload(value, tag))
+  end
+
+  def write_pair(value1, value2)
+    json = [ value1, value2 ]
+    write_value(JSON.generate(json))
+  end
+
+  def plot(dont_sync: false)
+    read_config
+
+    read unless dont_sync
+
+    plot = Plot.new
+    plot.show(local_csv_path(default_bucket_id))
+  end
+
+  def export(output_path)
+    read_config
+
+    content = Content.new
+    inner_items = read
+    inner_items.each do |inner_item|
+      content.add(inner_item)
+    end
+
+    content.write_as_json(output_path)
+  end
+
+  def consume_ticket(ticket_source_path)
+    read_config
+
+    ticket_target_path = File.join(config_dir, File.basename(ticket_source_path))
+    FileUtils.mv(ticket_source_path, ticket_target_path)
+    store = TicketStore.new(config_dir)
+    ticket = store.load_ticket_from_file(ticket_target_path)
+    self.default_bucket_id = ticket.bucket_id
+
+    write_config
+  end
+
+  def list_tickets(show_status: false)
+    read_config
+
+    store = TicketStore.new(config_dir)
+    out.puts "Available Tickets:"
+    store.tickets_per_server.each do |server_name,tickets|
+      if show_status
+        server_api = api(server_name)
+        begin
+          server_api.ping
+          status = " [pings]"
+        rescue StandardError => e
+          status = " [ping error: #{e.message.chomp}]"
+        end
+      end
+      out.puts "  Server '#{server_name}'#{status}:"
+      tickets.each do |ticket|
+        out.puts "    Bucket '#{ticket.name}' (#{ticket.bucket_id})"
+      end
+    end
+  end
+end

data/lib/myer/config.rb

@@ -0,0 +1,86 @@
+module Myer
+  module Config
+    include XDG::BaseDir::Mixin
+
+    def subdirectory
+      "myer"
+    end
+
+    attr_accessor :config_dir, :data_dir
+
+    def initialize_config
+      @config_dir = config.home.to_s
+      @data_dir = data.home.to_s
+    end
+
+    def local_csv_path(bucket_id)
+      File.join(@data_dir, bucket_id + ".csv")
+    end
+
+    class ServerConfig
+      attr_accessor :admin_id, :admin_password
+      attr_accessor :user_id, :user_password
+      attr_accessor :default_bucket_id
+
+      def initialize(yaml)
+        @admin_id = yaml["admin_id"]
+        @admin_password = yaml["admin_password"]
+        @user_id = yaml["user_id"]
+        @user_password = yaml["user_password"]
+        @default_bucket_id = yaml["default_bucket_id"]
+      end
+    end
+
+    def default_server=(value)
+      @config ||= {}
+      @config["default_server"] = value
+    end
+
+    def default_server
+      @config["default_server"]
+    end
+
+    def self.define_attribute(name)
+      define_method(name.to_s) do
+        return nil if !@config
+        @config["servers"][default_server][name.to_s]
+      end
+
+      define_method(name.to_s + "=") do |value|
+        @config ||= {}
+        @config["servers"] ||= {}
+        @config["servers"][default_server] ||= {}
+        @config["servers"][default_server][name.to_s] = value
+      end
+    end
+
+    define_attribute :admin_id
+    define_attribute :admin_password
+    define_attribute :user_id
+    define_attribute :user_password
+    define_attribute :default_bucket_id
+
+    def write_config
+      FileUtils.mkdir_p(@config_dir)
+      File.write(File.join(@config_dir, "myer.config"), @config.to_yaml)
+    end
+
+    def read_config
+      config_file = File.join(@config_dir, "myer.config")
+      return if !File.exist?(config_file)
+
+      @config = YAML.load_file(config_file)
+
+      @default_server = @config["default_server"]
+    end
+
+    def servers
+      @config["servers"].keys
+    end
+
+    def server(name)
+      return nil if !@config["servers"] || !@config["servers"].has_key?(name)
+      ServerConfig.new(@config["servers"][name])
+    end
+  end
+end

data/lib/myer/content.rb

@@ -0,0 +1,92 @@
+class Content
+  class Item
+    attr_accessor :id, :written_at, :tag
+
+    def initialize(container)
+      @container = container
+    end
+
+    def data=(value)
+      @data = value
+    end
+
+    def data
+      if @container.type == "json"
+        JSON.parse(@data)
+      else
+        @data
+      end
+    end
+  end
+
+  attr_reader :title, :type
+
+  def initialize
+    @items = []
+  end
+
+  def add(content)
+    json = JSON.parse(content)
+
+    item = Item.new(self)
+    item.id = json["id"]
+    item.written_at = json["written_at"]
+    item.tag = json["tag"]
+    if item.tag == "title"
+      @title = json["data"]
+    elsif item.tag == "type"
+      @type = json["data"]
+    else
+      item.data = json["data"]
+      @items.push(item)
+    end
+  end
+
+  def first
+    at(0)
+  end
+
+  def at(index)
+    @items.at(index)
+  end
+
+  def empty?
+    @items.empty?
+  end
+
+  def length
+    @items.length
+  end
+
+  def write_as_csv(output_path)
+    File.open(output_path, "w") do |file|
+      @items.each do |item|
+        if type == "json"
+          file.puts(item.data.join(","))
+        else
+          file.puts(item.data)
+        end
+      end
+    end
+  end
+
+  def write_as_json(output_path)
+    json = {}
+    json["title"] = title
+
+    data_array = []
+    @items.each do |item|
+      data_item = {}
+      data_item["date"] = item.data[0]
+      data_item["value"] = item.data[1]
+
+      data_array.push(data_item)
+    end
+
+    json["data"] = data_array
+
+    File.open(output_path, "w") do |file|
+      file.write(json.to_json)
+    end
+  end
+end

data/lib/myer/crypto.rb

@@ -0,0 +1,40 @@
+class Crypto
+
+  attr_accessor :passphrase
+
+  def generate_passphrase
+    `gpg --armor --gen-random 1 16`.chomp
+  end
+
+  def call_cmd(cmd, input)
+    output = nil
+    Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
+      stdin.puts(input)
+      stdin.close
+      output = stdout.read
+
+      if !wait_thr.value.success?
+        raise Myer::CmdFailed.new(stderr.read)
+      end
+    end
+    output
+  end
+
+  def encrypt(plaintext)
+    cmd = "gpg --batch --armor --passphrase '#{passphrase}' --symmetric"
+    begin
+      return call_cmd(cmd, plaintext)
+    rescue Myer::CmdFailed => e
+      raise "Encryption failed: #{e}"
+    end
+  end
+
+  def decrypt(ciphertext)
+    cmd = "gpg --batch --passphrase '#{passphrase}' --decrypt"
+    begin
+      return call_cmd(cmd, ciphertext).chomp
+    rescue Myer::CmdFailed => e
+      raise Myer::DecryptionFailed.new("Decryption failed: #{e}")
+    end
+  end
+end

data/lib/myer/exceptions.rb

@@ -0,0 +1,7 @@
+module Myer
+  class Error < StandardError; end
+
+  class CmdFailed < Error; end
+  class DecryptionFailed < Error; end
+end
+

data/lib/myer/plot.rb

@@ -0,0 +1,11 @@
+class Plot
+  def call_helper(csv_file_path)
+    plot_helper = File.expand_path( "../../../scripts/plot-helper.py", __FILE__ )
+    cmd = "python #{plot_helper} #{csv_file_path}"
+    system(cmd)
+  end
+
+  def show(csv_file)
+    call_helper(csv_file)
+  end
+end

data/lib/myer/proc_net_parser.rb

@@ -0,0 +1,11 @@
+class ProcNetParser
+  attr_reader :received_bytes
+
+  def parse(input)
+    input.each_line do |line|
+      if line =~ /^en(.*):\s+(\d+)\s+/
+        @received_bytes = $2.to_i
+      end
+    end
+  end
+end