1月 « 2018 « shell-mag

第21回　サーバーを守る（ファイアウォール）

投稿日：2018.01.26　｜　カテゴリー：　記事

不正なアクセスなどからサーバーやネットワークを守る仕組みとして「ファイアウォール」があります。ファイアウォールは、日本語で「防火壁」という意味です。ファイアウォールを通過する通信を監視し、サーバーやネットワーク内外への不適切な通信の遮断などに利用します（図1）。

図1　ファイアウォールによるアクセス制御

通常、インターネットの出入り口に配置される「ゲートウェイ」となるルーター（ブロードバンドルーター）がファイアウォールの機能を備えています。ただ、連載第10回で説明したDMZ（非武装地帯）に配置したサーバーの場合、内部にファイアウォールを設置して自らを守る必要があります。

普及期を向かえたコンテナー型仮想化ソフトウエア「Docker」。ITエンジニアとしては、知っておくべきものの一つです。特集1では、Dockerの概要や仕組みを説明し、CentOS上への導入方法や基本的使い方を紹介しています。
特集2では、シェルスクリプトマガジン編集とビット・トレード・ワンで共同制作したRaspberry Pi用拡張ボード「ラズパイ入門ボード」の使用方法を解説しています。LEDやスイッチ、圧電スピーカーなどの制御を学ぶにはビッタリです。本誌と同時にラズパイ入門ボードも発売しますので、一緒に購入してラズパイプログラミングを楽しんでみてください。
そのほか、大学研究室や農業体験を紹介する連載記事を開始しました。

今月も読み応え十分のシェルスクリプトマガジン Vol.52。お見逃しなく!

※ラズパイ入門ボード購入に関してはこちら

※読者アンケートはこちら

シェルスクリプトマガジンvol.52 Web掲載記事まとめ

投稿日：2018.01.23　｜　カテゴリー：　記事

シェルスクリプトマガジンvol.52のWeb掲載部分まとめです。

プレゼント＆アンケートページはこちら！

シェルスクリプトマガジンvol.52は以下リンク先でご購入できます。

4 レポート　スマートスピーカーが相次いで登場

6 特集1　Dockerを使ってみよう/末安泰三

20 特集2　ラズパイ入門ボードの使い方/米田聡コード掲載

30 RESEARCHES FOR FUTURE 千葉工業大学先進工学部未来ロボティクス学科自律ロボット研究室/上田隆一

32 機械学習のココロ丁半バクチで勝負する機械学習の世界（モンテカルロ法）/石井一夫リンク掲載

39 姐のNOGYO 40 アジャイル開発 Let’s Practice! システム設計/熊野憲辰

44 中小企業手作りIT化奮戦記　第32回　眠れない地獄の夜/菅雄一

50 円滑コミュニケーションが世界を救う！/濱口誠一

52 縁の木、育てようゲストエウレカ森川託磨さん /白羽玲子

56 人と月/桑原滝弥・イケヤシロウ

58 コボラーによるコボラーのためのユニケージ入門　COBOLとユニケージの違い/野村祐三

64 漢のUNIX　サードパーティ製ライブラリを使う/後藤大地コード掲載

73 バーティカルバーの極意/飯尾淳

78 人間とコンピュータの可能性/大岩元

80 香川大学SLPからお届け！/花川直己、家平和輝、森田浩平

84 法林浩之のFIGHTING TALKS/法林浩之

86 40歳から始める、オレとRubyプログラミング/しょっさんコード掲載

96 ITエンジニアのためのマーケティング入門　第28回　デジタルマーケティングその4/水間丈博

100 Techパズル/gori.sh

102 1足す1は3にはならない/シェル魔人

機械学習のココロ（vol.52掲載）

投稿日：2018.01.23　｜　カテゴリー：　コード

著者：石井一夫（久留米大学）

世の中は機械学習や人工知能のブームです。これに相まって、統計学や数学の価値が再認識されています。数学と聞くと学生の頃のトラウマが甦り、ついつい敬遠しがちな人もいるかもしれませんが、ある種の必要性と割り切り、ワクワクするような新しいトレンドとして再認識できると、それなりに楽しいものです。

記事本文掲載のシェルスクリプトマガジンvol.52は以下のリンク先でご購入できます。

「1、円周率の計算」の参考にしているサイトへのリンク（リンク先にコード有り）

pythonで円周率を求める　（Remrinのpython攻略日記）

「２、積分計算と確率計算」の参考にしているサイトへのリンク（リンク先にコード有り）

モンテカルロ積分　（人工知能に関する断創録）

「3、機械学習モデルとしての最尤推定法、最小二乗法、回帰分析への応用」の参考リンク（説明のみ）

最小二乗法と最尤法の関係　（具体例で学ぶ数学）

「4、ベイズ予測モデルを作成するためのマルコフ連鎖モンテカルロ法」の参考リンク（リンク先にコード有り）

The Bayesian t-Test　（henryhhammond.com）

ラズパイ入門ボードの購入について

投稿日：2018.01.19　｜　カテゴリー：　コード

動画による製品紹介はこちら

プログラミング例はこちら

シェルスクリプトマガジン（Vol.52）の特集2で紹介したラズパイ入門ボードの完成品20セット、組み立てキット10セットを限定発売します（日本国内のみ）。お1人様どちらか1セットになります。

完成品が3980円（税別）、組み立てキットが2780円（税別）です。送料は650円（税込み）になります（シェルスクリプトマガジン Vo．52は完売しました）。PayPalまたは銀行振り込みでのお支払いになります。

以下の購入申し込みを記入の上、「raspi@usp-lab.com」宛てにメールしてください。2~3営業日以内にメールにて支払い方法などをお送りいたします。発送はVol.52発売日の2018年1月25日以降になります。なお、売り切れの場合もご連絡いたします。

売り切れの際は、ビット・トレード・ワンの公式オンラインショップ、Amazon.co.jp、共立エレショップおよび、シリコンハウス各店、千石電商各店、デジット各店、マルツエレック各店からご購入ください（いずれも1月25日販売開始予定）。

++++++ラズパイ入門ボード購入申し込み++++++

■購入希望商品

○完成品：4948円
○組み立てキット：3652円
※購入を希望する商品の「○」を「●」に変更してください。

■代金お支払い方法

○PayPal

○銀行振り込み

※希望する方の「○」を「●」に変更してください。

お名前：
お名前のよみがな：
郵便番号：
ご住所：
お電話番号：
+++++++++++++++++++++++++++++++++

第20回　オンラインストレージを作る（アプリ導入）

投稿日：2018.01.19　｜　カテゴリー：　記事

前回は「Nextcloud」のユーザー作成と基本操作を解説しました。今回は、Netcloudの機能を拡張するアプリについて紹介します。Netcloudの本体には、オンラインストレージに必要な最低限の機能しか組み込まれていません。Netcloudに組み込むことができるアプリを有効化することによって、Googleカレンダーや、Googleドライブのようなオンラインオフィス機能などを追加できます（図1）。

図1　アプリを有効にすることでNextcloudの機能拡張ができる

それでは、前回と同様にリモートアクセス用パソコンでWebブラウザーを起動して「http://Ubuntu ServerのIPアドレス:8080/」にアクセスします。ログイン画面から管理者アカウントでログインします。

第19回　オンラインストレージを作る（基本操作）

投稿日：2018.01.12　｜　カテゴリー：　記事

前回は「Nextcloud」を使ってオンラインストレージを構築しました。今回は、Netcloudのユーザー作成と基本的な使い方を紹介します。
前回と同様にリモートアクセス用パソコンでWebブラウザーを起動して、「http://Ubuntu ServerのIPアドレス:8080/」にアクセスします。ログイン画面から管理者アカウントでログインします（図1）。

図1　Nextcloudのログイン画面

ラズパイ入門ボード向けソースコード集

投稿日：2018.01.10　｜　カテゴリー：　コード

シェルスクリプトマガジンとビット・トレード・ワンで共同制作したRaspberry Pi拡張ボード「ラズパイ入門ボード」のソースコード集です。雑誌と一緒にご活用ください。

ソースコードの入手先

※関連記事掲載時に追加していきます。

※ラズパイセンサーボード向けソースコード集はこちら。

40歳から始める、オレとRubyプログラミング（vol.52掲載）

投稿日：2018.01.10　｜　カテゴリー：　コード

著者：しょっさん

前回は、インフラ管理アプリ「Reins」の今後の方針について、「プログラムを俯瞰してリファクタリングしよう」「Reins Agentを監視できるようにしよう」「データフォーマットを標準化しよう」という三つのポイントに着目して定めました。
今回は、前回定めた方針に従って、プログラムを更新します。ただし、すべての変更点を載せるとプログラムだけでも相当な分量になりそうだったので、次の二つについてのみ、プログラムと変更点を説明します。
記事本文掲載のシェルスクリプトマガジンvol.52は以下のリンク先でご購入できます。

# coding: utf-8

# filename: reins_spec.rb
require "spec_helper"
require "socket"

RSpec.describe Reins do
  describe "定数/変数の設定" do
    it { expect(Reins::VERSION).not_to be nil }
    it { expect(Reins.port).not_to be nil }
    it { expect(Reins.logger).not_to be nil }
    it { expect(Reins.auth_service).not_to be nil }
    it { expect(Reins.regist_host).not_to be nil }
  end

  # AuthService class のテスト
  describe "AuthService" do
    describe "#authenticate_key" do
      let(:sha512) { "106a6484291b9778c224731501d2deeb71f2b83558a0e9784fe33646f56182f69de448e92fe83fd4e57d629987f9d0dd79bf1cbca4e83b996e272ba44faa6adb" }
      let(:normal) { Reins::AuthService.new }
      let(:other)  { Reins::AuthService.new(sha512) }
      before do
        allow(Reins.regist_host).to receive(:store).and_return(true)
      end

      context "ハッシュキーを作成する場合" do
        it { expect(normal.create_key('192.168.0.10')).to match(/[0-9a-f]{128}/) }
      end

      context "正常に認証された場合" do
        it { expect(normal.authenticate_key('DEMO', '192.168.0.10')).not_to eq(false) }
        it { expect(other.authenticate_key('40ruby', '192.168.0.10')).not_to eq(false) }
      end

      context "異なる認証キーで呼び出された場合" do
        it { expect(normal.authenticate_key('TEST', '192.168.0.10')).to eq(false) }
        it { expect(other.authenticate_key('DEMO', '192.168.0.10')).to eq(false) }
      end
    end

    describe "#varid?" do
      let(:auth) { Reins::AuthService.new }
      let(:key)  { auth.authenticate_key('DEMO', '192.168.0.10') }

      it { expect(auth.varid?(key)).to eq('192.168.0.10') }
    end
  end

  # HostRegistry Class のテスト
  describe 'HostRegistry' do
    let(:regist_test)    { Reins::HostRegistry.new("test_db.json") }
    let(:test_key)       { "TestKey" }
    let(:localhost)       { '127.0.0.1' }
    let(:correct_hosts)   { ['192.168.0.10', '1.0.0.1', '239.255.255.254'] }

    before do
      allow(regist_test).to receive(:store).and_return(true)
    end

    describe '#create' do
      subject { regist_test.create(localhost, test_key) }
      before do
        regist_test.create(localhost, test_key)
      end
      it { is_expected.to eq(false) }
    end

    describe '#get_status' do
      subject { regist_test.get_status(localhost, test_key) }
      before do
        regist_test.create(localhost, test_key)
      end
      context '登録直後の場合' do
        it { is_expected.to eq("alive") }
      end
      context 'ステータスを"alive"へ変更した場合' do
        it '#set_status で "alive" をセット' do
          regist_test.set_status(localhost, test_key, "alive")
          is_expected.to eq("alive")
        end
      end
      context 'ステータスが"dead"の場合' do
        it '#set_status で "dead" をセット' do
          regist_test.set_status(localhost, test_key, "dead")
          is_expected.to eq("dead")
        end
      end
      context '未登録のホストの場合' do
        it '登録していないホストのステータスを確認するとfalse' do
          expect(regist_test.get_status("192.168.0.10", test_key)).to eq(false)
        end
        it '未登録のホストステータスを変更するとfalse' do
          expect(regist_test.set_status("192.168.0.10", test_key, "alive")).to eq(false)
          expect(regist_test.get_status("192.168.0.10", test_key)).to eq(false)
        end
      end
    end

    describe '#read_hosts' do
      subject { regist_test.read_hosts }
      context '正常に登録されている場合' do
        it { is_expected.to eq([]) }
        it 'localhost を1つ登録すると、[127.0.0.1]' do
          regist_test.create(localhost, test_key)
          is_expected.to eq([localhost])
        end
        it '複数のアドレスを登録した場合は、複数のアドレス' do
          correct_hosts.each { |host| regist_test.create(host, test_key) }
          is_expected.to match_array(correct_hosts)
        end
      end
    end

    describe '#read_hostkeys' do
      it '登録しなければ、空' do
        expect(regist_test.hosts).to eq({})
        expect(regist_test.read_hostkeys).to eq({})
        expect(regist_test.read_hostkeys.size).to eq(0)
      end
      it 'ハッシュ化された接続キーの一覧' do
        correct_hosts.each { |host| regist_test.create(host, test_key) }
        expect(regist_test.read_hostkeys.size).to eq(3)
      end
    end

    describe '#delete' do
      before { regist_test.create("192.168.0.1", test_key) }
      subject { regist_test.delete(localhost) }
      context '正常に削除できる場合' do
        it '登録済みのアドレスを削除すると、そのアドレス' do
          regist_test.create(localhost, test_key)
          is_expected.to eq(localhost)
        end
      end
      context '削除できない場合' do
        it { is_expected.to eq(nil) }
      end
    end
  end

  # TaskControl class のテスト
  describe 'TaskControl' do
    before { @server = TCPServer.new(24_368) }
    after  { @server.close }
    let(:tasks) { Reins::TaskControl.new }
    let(:no_task) { Reins::TaskControl.new('localhost', 65_000) }

    describe '#connect' do
      context 'クライアントへ接続できる場合' do
        subject { tasks.connect }
        it 'モックを使って正常接続のコール' do
          allow(tasks).to receive(:connect).and_return(true)
          is_expected.to eq(true)
        end
      end

      context 'クライアントへ接続できない場合' do
        it { expect(no_task.connect).to eq(false) }
        it 'クライアントが停止していたら false' do
          allow(tasks).to receive(:connect).and_return(false)
          expect(tasks.connect).to eq(false)
        end
      end
    end

    describe '#disconnect' do
      context '正常に切断できた場合' do
        subject { tasks.disconnect }
        it 'こちらから、クライアントとの接続を切断して、成功すると nil' do
          is_expected.to eq(nil)
        end
      end
    end
  end

  # Dispatcher class のテスト
  describe 'Dispatch' do
    let(:test_key)       { "TestKey" }
    let(:correct_host)   { Reins::Dispatch.new("192.168.0.10", test_key) }

    before { allow(correct_host).to receive(:varidate).and_return(true) }

    describe '#command' do
      context 'ホスト一覧を出力する場合' do
        it 'ホスト一覧が出力された' do
          allow(Reins.regist_host).to receive(:read_hosts).and_return([])
          expect(correct_host.command("list", "")).to eq([])
        end
      end
      context 'アドレスを削除する場合' do
        it 'アドレスを正常に削除' do
          allow(Reins.regist_host).to receive(:delete).and_return("192.168.0.10")
          expect(correct_host.command("delete", "")).to eq("192.168.0.10")
        end
      end
    end
  end
end

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

# coding: utf-8

# filename: reins_spec.rb

require "spec_helper"

require "socket"

RSpec.describe Reins do

describe "定数/変数の設定" do

it { expect(Reins::VERSION).not_to be nil }

it { expect(Reins.port).not_to be nil }

it { expect(Reins.logger).not_to be nil }

it { expect(Reins.auth_service).not_to be nil }

it { expect(Reins.regist_host).not_to be nil }

end

# AuthService class のテスト

describe "AuthService" do

describe "#authenticate_key" do

let(:sha512) { "106a6484291b9778c224731501d2deeb71f2b83558a0e9784fe33646f56182f69de448e92fe83fd4e57d629987f9d0dd79bf1cbca4e83b996e272ba44faa6adb" }

let(:normal) { Reins::AuthService.new }

let(:other) { Reins::AuthService.new(sha512) }

before do

allow(Reins.regist_host).to receive(:store).and_return(true)

end

context "ハッシュキーを作成する場合" do

it { expect(normal.create_key('192.168.0.10')).to match(/[0-9a-f]{128}/) }

end

context "正常に認証された場合" do

it { expect(normal.authenticate_key('DEMO', '192.168.0.10')).not_to eq(false) }

it { expect(other.authenticate_key('40ruby', '192.168.0.10')).not_to eq(false) }

end

context "異なる認証キーで呼び出された場合" do

it { expect(normal.authenticate_key('TEST', '192.168.0.10')).to eq(false) }

it { expect(other.authenticate_key('DEMO', '192.168.0.10')).to eq(false) }

end

describe "#varid?" do

let(:auth) { Reins::AuthService.new }

let(:key) { auth.authenticate_key('DEMO', '192.168.0.10') }

it { expect(auth.varid?(key)).to eq('192.168.0.10') }

end

# HostRegistry Class のテスト

describe 'HostRegistry' do

let(:regist_test) { Reins::HostRegistry.new("test_db.json") }

let(:test_key) { "TestKey" }

let(:localhost) { '127.0.0.1' }

let(:correct_hosts) { ['192.168.0.10', '1.0.0.1', '239.255.255.254'] }

before do

allow(regist_test).to receive(:store).and_return(true)

end

describe '#create' do

subject { regist_test.create(localhost, test_key) }

before do

regist_test.create(localhost, test_key)

end

it { is_expected.to eq(false) }

end

describe '#get_status' do

subject { regist_test.get_status(localhost, test_key) }

before do

regist_test.create(localhost, test_key)

end

context '登録直後の場合' do

it { is_expected.to eq("alive") }

end

context 'ステータスを"alive"へ変更した場合' do

it '#set_status で "alive" をセット' do

regist_test.set_status(localhost, test_key, "alive")

is_expected.to eq("alive")

end

context 'ステータスが"dead"の場合' do

it '#set_status で "dead" をセット' do

regist_test.set_status(localhost, test_key, "dead")

is_expected.to eq("dead")

end

context '未登録のホストの場合' do

it '登録していないホストのステータスを確認するとfalse' do

expect(regist_test.get_status("192.168.0.10", test_key)).to eq(false)

end

it '未登録のホストステータスを変更するとfalse' do

expect(regist_test.set_status("192.168.0.10", test_key, "alive")).to eq(false)

expect(regist_test.get_status("192.168.0.10", test_key)).to eq(false)

end

describe '#read_hosts' do

subject { regist_test.read_hosts }

context '正常に登録されている場合' do

it { is_expected.to eq([]) }

it 'localhost を1つ登録すると、[127.0.0.1]' do

regist_test.create(localhost, test_key)

is_expected.to eq([localhost])

end

it '複数のアドレスを登録した場合は、複数のアドレス' do

correct_hosts.each { |host| regist_test.create(host, test_key) }

is_expected.to match_array(correct_hosts)

end

describe '#read_hostkeys' do

it '登録しなければ、空' do

expect(regist_test.hosts).to eq({})

expect(regist_test.read_hostkeys).to eq({})

expect(regist_test.read_hostkeys.size).to eq(0)

end

it 'ハッシュ化された接続キーの一覧' do

correct_hosts.each { |host| regist_test.create(host, test_key) }

expect(regist_test.read_hostkeys.size).to eq(3)

end

describe '#delete' do

before { regist_test.create("192.168.0.1", test_key) }

subject { regist_test.delete(localhost) }

context '正常に削除できる場合' do

it '登録済みのアドレスを削除すると、そのアドレス' do

regist_test.create(localhost, test_key)

is_expected.to eq(localhost)

end

context '削除できない場合' do

it { is_expected.to eq(nil) }

end

# TaskControl class のテスト

describe 'TaskControl' do

before { @server = TCPServer.new(24_368) }

after { @server.close }

let(:tasks) { Reins::TaskControl.new }

let(:no_task) { Reins::TaskControl.new('localhost', 65_000) }

describe '#connect' do

context 'クライアントへ接続できる場合' do

subject { tasks.connect }

it 'モックを使って正常接続のコール' do

allow(tasks).to receive(:connect).and_return(true)

is_expected.to eq(true)

end

context 'クライアントへ接続できない場合' do

it { expect(no_task.connect).to eq(false) }

it 'クライアントが停止していたら false' do

allow(tasks).to receive(:connect).and_return(false)

expect(tasks.connect).to eq(false)

end

describe '#disconnect' do

context '正常に切断できた場合' do

subject { tasks.disconnect }

it 'こちらから、クライアントとの接続を切断して、成功すると nil' do

is_expected.to eq(nil)

end

# Dispatcher class のテスト

describe 'Dispatch' do

let(:test_key) { "TestKey" }

let(:correct_host) { Reins::Dispatch.new("192.168.0.10", test_key) }

before { allow(correct_host).to receive(:varidate).and_return(true) }

describe '#command' do

context 'ホスト一覧を出力する場合' do

it 'ホスト一覧が出力された' do

allow(Reins.regist_host).to receive(:read_hosts).and_return([])

expect(correct_host.command("list", "")).to eq([])

end

context 'アドレスを削除する場合' do

it 'アドレスを正常に削除' do

allow(Reins.regist_host).to receive(:delete).and_return("192.168.0.10")

expect(correct_host.command("delete", "")).to eq("192.168.0.10")

end

# coding: utf-8

require 'digest/sha2'

module Reins
  class AuthService
    # サーバの認証キーを定義する
    # == パラメータ
    # secret_key:: SHA512 でハッシュ化されたキーを指定する
    # == 返り値
    # nil
    def initialize(secret_key = 'ac58c2bedf7c1d4e35136f2ca4f81acdece03fa9e90aeefa0d363488649c7f52d7064285923f814592d53c419f5c4db59ee1a867b4852d18e0fac6efd5874072')
      @secret_key = secret_key
      nil
    end

    # IPアドレスをキーにした専用のキーを発行し、新しいキーを登録する
    # == パラメータ
    # ipaddr:: IPアドレス
    # == 返り値
    # キー:: ハッシュ化された識別キー
    def create_key(ipaddr)
      new_key = Digest::SHA512.hexdigest("#{ipaddr}:#{Random.new_seed}")
      Reins.regist_host.create(ipaddr, new_key)
    end

    # クライアント認証を行う
    # 接続元が要求してきたキーが、サーバ側で設定されているハッシュ値と比較する
    # == パラメータ
    # key:: ハッシュ化される前のキー
    # ipaddr:: 接続元のIPアドレス
    # == 返り値
    # キー:: 新規にホスト登録が必要なクライアントキーを発行
    # true:: 認証成功
    # false:: 認証不可 または、新規登録不可
    def authenticate_key(key, ipaddr)
      if @secret_key == Digest::SHA512.hexdigest(key)
        Reins.logger.info("#{ipaddr} : 認証が成功しました")
        Reins.regist_host.read_hosts.include?(ipaddr) ? Reins.regist_host.read_hostkeys[ipaddr] : create_key(ipaddr)
      else
        Reins.logger.fatal("#{ipaddr} : 認証が失敗しました")
        false
      end
    end

    # クライアントの識別を行う
    # 要求されたクライアント固有の識別キーが登録されているものか判断する
    # == パラメータ
    # key:: クライアント固有の識別キー
    # == 返り値
    # 識別された場合:: 登録されているIPアドレス
    # 否認された場合:: nil
    def varid?(keycode)
      Reins.regist_host.read_hostkeys.key(keycode)
    end
  end
end

# coding: utf-8

require 'digest/sha2'

module Reins

class AuthService

# サーバの認証キーを定義する

# == パラメータ

# secret_key:: SHA512 でハッシュ化されたキーを指定する

# == 返り値

# nil

def initialize(secret_key = 'ac58c2bedf7c1d4e35136f2ca4f81acdece03fa9e90aeefa0d363488649c7f52d7064285923f814592d53c419f5c4db59ee1a867b4852d18e0fac6efd5874072')

@secret_key = secret_key

nil

end

# IPアドレスをキーにした専用のキーを発行し、新しいキーを登録する

# == パラメータ

# ipaddr:: IPアドレス

# == 返り値

# キー:: ハッシュ化された識別キー

def create_key(ipaddr)

new_key = Digest::SHA512.hexdigest("#{ipaddr}:#{Random.new_seed}")

Reins.regist_host.create(ipaddr, new_key)

end

# クライアント認証を行う

# 接続元が要求してきたキーが、サーバ側で設定されているハッシュ値と比較する

# == パラメータ

# key:: ハッシュ化される前のキー

# ipaddr:: 接続元のIPアドレス

# == 返り値

# キー:: 新規にホスト登録が必要なクライアントキーを発行

# true:: 認証成功

# false:: 認証不可または、新規登録不可

def authenticate_key(key, ipaddr)

if @secret_key == Digest::SHA512.hexdigest(key)

Reins.logger.info("#{ipaddr} : 認証が成功しました")

Reins.regist_host.read_hosts.include?(ipaddr) ? Reins.regist_host.read_hostkeys[ipaddr] : create_key(ipaddr)

else

Reins.logger.fatal("#{ipaddr} : 認証が失敗しました")

false

end

# クライアントの識別を行う

# 要求されたクライアント固有の識別キーが登録されているものか判断する

# == パラメータ

# key:: クライアント固有の識別キー

# == 返り値

# 識別された場合:: 登録されているIPアドレス

# 否認された場合:: nil

def varid?(keycode)

Reins.regist_host.read_hostkeys.key(keycode)

end

# coding: utf-8

# filename: dispatcher.rb
module Reins
  class Dispatch
    # 対象となるクライアントのIPアドレスを保持
    # == パラメータ
    # ip:: 対象となるクライアントのIPアドレス
    # == 返り値
    # 特になし
    def initialize(addr, keycode)
      @addr    = addr
      @keycode = keycode
    end

    def varidate
      return true if Reins.regist_host.read_hostkeys[@addr] == @keycode

      Reins.logger.error("認可されていないコマンドです")
      false
    end

    # コマンドを受け取って、対象の機能へ振り分ける
    # == パラメータ
    # comm:: クライアントからの要求コマンド
    # value:: コマンドの実行に必要な引数
    # == 返り値
    # exception:: 失敗した場合
    # exception以外:: コマンドの実行結果
    def command(comm, value)
      Reins.logger.debug("#{comm}(#{value}) : 指定のコマンドへディスパッチします")
      return "false" unless varidate
      case comm
      when /^list/
        Reins.regist_host.read_hosts
      when /^delete/
        Reins.regist_host.delete(@addr)
      end
    end
  end
end

# coding: utf-8

# filename: dispatcher.rb

module Reins

class Dispatch

# 対象となるクライアントのIPアドレスを保持

# == パラメータ

# ip:: 対象となるクライアントのIPアドレス

# == 返り値

# 特になし

def initialize(addr, keycode)

@addr = addr

@keycode = keycode

end

def varidate

return true if Reins.regist_host.read_hostkeys[@addr] == @keycode

Reins.logger.error("認可されていないコマンドです")

false

end

# コマンドを受け取って、対象の機能へ振り分ける

# == パラメータ

# comm:: クライアントからの要求コマンド

# value:: コマンドの実行に必要な引数

# == 返り値

# exception:: 失敗した場合

# exception以外:: コマンドの実行結果

def command(comm, value)

Reins.logger.debug("#{comm}(#{value}) : 指定のコマンドへディスパッチします")

return "false" unless varidate

case comm

when /^list/

Reins.regist_host.read_hosts

when /^delete/

Reins.regist_host.delete(@addr)

end

# coding: utf-8

# filename: host_registry.rb
require 'json'
require 'ipaddr'

module Reins
  class HostRegistry
    attr_reader :hosts

    # データベースの読込・初期化
    # ファイルが存在していれば内容を読込、なければファイルを新規に作成
    # == パラメータ
    # filename:: 読込・または保管先のファイル名
    # == 返り値
    # 特になし。但し、@hosts インスタンス変数へ、データベースの内容を保持
    def initialize(filename)
      @filename = filename
      File.open(@filename) do |file|
        @hosts = JSON.parse(file)
      end
    rescue
      @hosts = {}
    end

    # メモリ上のアドレスリストを、ファイルへ保管する
    # == パラメータ
    # filename:: 保管先ファイル名。指定がない場合は、初期化時に採用したファイル名
    def store(filename = @filename)
      Reins.logger.debug("#{filename} : ホスト一覧を保存します")
      File.open(filename, "w") do |file|
        file.puts(JSON.pretty_generate(@hosts))
      end
      true
    rescue
      Reins.logger.fatal("#{e}: データの保管に失敗しました")
      false
    end

    # 登録可能かどうかを検査する
    # == パラメータ
    # ipaddr:: 検査するIPアドレス
    # == 返り値
    # IPアドレス:: 登録可能な場合 IPアドレスを返す
    # false:: 登録不可
    def varid_ip?(ipaddr)
      addr = IPAddr.new(ipaddr).native.to_s
      @hosts.key?(addr) ? false : addr
    rescue => e
      Reins.logger.error("#{e}: #{ipaddr} は登録可能なIPアドレスではありません")
      false
    end

    # アドレスを新規に登録する。既に登録済みのものであれば登録しない。
    # == パラメータ
    # ipaddr:: 登録するIPアドレス
    # key:: 登録する IPアドレスをキーにした、接続用Keyをもつハッシュデータ
    # == 返り値
    # true::  登録できた
    # false:: 既に同じアドレスまたはIPアドレスではないため、登録せず
    def create(ipaddr, key)
      if (addr = varid_ip?(ipaddr))
        @hosts[addr] = {}
        @hosts[addr]["keycode"]      = key
        @hosts[addr]["created_date"] = @hosts[addr]["updated_date"] = Time.now.getlocal
        @hosts[addr]["status"]       = "alive"
        Reins.logger.info("#{addr} を追加しました")
        key if store
      else
        false
      end
    end

    # 登録されたステータスを変更する
    # == パラメータ
    # ipaddr:: 登録済みIPアドレス
    # key:: 登録する IPアドレスをキーにした、接続用Keyをもつハッシュデータ
    # status:: "alive" 稼働中, "dead" 異常発生し停止
    # == 返り値
    # "alive" or "dead"::  変更したホストのステータス
    # false:: 未登録ホストの場合、または Keyがまちがっている
    def get_status(ipaddr, key)
      @hosts[ipaddr]["keycode"] == key ? @hosts[ipaddr]["status"] : false
    rescue
      false
    end

    # 登録されたステータス情報を得る
    # == パラメータ
    # ipaddr:: 登録済みIPアドレス
    # key:: 登録する IPアドレスをキーにした、接続用Keyをもつハッシュデータ
    # == 返り値
    # "alive" or "dead"::  登録されているホストのステータス
    # false:: 未登録、または停止中、または Keyがまちがっている
    def set_status(ipaddr, key, status)
      if @hosts[ipaddr]["keycode"] == key
        @hosts[ipaddr]["status"]     = status
        @hosts[addr]["updated_date"] = Time.now.getlocal
        store
        status
      else
        false
      end
    rescue
      false
    end

    # 登録済みホスト一覧を、IPアドレスをKey、接続KeyをValueとするハッシュで返す
    # == 返り値
    # hash: hash[ipアドレス] = key を一つの要素とする
    def read_hostkeys
      @hosts.each_key.map do |host|
        [host, @hosts[host]["keycode"]]
      end.to_h
    end

    # 登録済みホスト一覧を配列で返す
    # == 返り値
    # array: 登録済みのIPアドレス一覧
    def read_hosts
      @hosts.each_key.map { |host| host }
    end

    # 登録済みのアドレスを削除する
    # == パラメータ
    # addr: 削除対象のアドレス
    # == 返り値
    # string:: 削除された要素
    # nil::    削除すべき要素が見つからなかったとき
    def delete(addr)
      if @hosts.delete(addr)
        Reins.logger.info("#{addr} を削除しました.")
        store
        addr
      else
        Reins.logger.warn("#{addr} を削除できません.")
        nil
      end
    end

    # まだアドレスが登録されていないかどうか
    # == 返り値
    # true::  アドレス未登録
    # false:: 1つ以上のアドレスが登録済み
    def empty?
      @hosts.empty?
    end
  end
end

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

# coding: utf-8

# filename: host_registry.rb

require 'json'

require 'ipaddr'

module Reins

class HostRegistry

attr_reader :hosts

# データベースの読込・初期化

# ファイルが存在していれば内容を読込、なければファイルを新規に作成

# == パラメータ

# filename:: 読込・または保管先のファイル名

# == 返り値

# 特になし。但し、@hosts インスタンス変数へ、データベースの内容を保持

def initialize(filename)

@filename = filename

File.open(@filename) do |file|

@hosts = JSON.parse(file)

end

rescue

@hosts = {}

end

# メモリ上のアドレスリストを、ファイルへ保管する

# == パラメータ

# filename:: 保管先ファイル名。指定がない場合は、初期化時に採用したファイル名

def store(filename = @filename)

Reins.logger.debug("#{filename} : ホスト一覧を保存します")

File.open(filename, "w") do |file|

file.puts(JSON.pretty_generate(@hosts))

end

true

rescue

Reins.logger.fatal("#{e}: データの保管に失敗しました")

false

end

# 登録可能かどうかを検査する

# == パラメータ

# ipaddr:: 検査するIPアドレス

# == 返り値

# IPアドレス:: 登録可能な場合 IPアドレスを返す

# false:: 登録不可

def varid_ip?(ipaddr)

addr = IPAddr.new(ipaddr).native.to_s

@hosts.key?(addr) ? false : addr

rescue => e

Reins.logger.error("#{e}: #{ipaddr} は登録可能なIPアドレスではありません")

false

end

# アドレスを新規に登録する。既に登録済みのものであれば登録しない。

# == パラメータ

# ipaddr:: 登録するIPアドレス

# key:: 登録する IPアドレスをキーにした、接続用Keyをもつハッシュデータ

# == 返り値

# true:: 登録できた

# false:: 既に同じアドレスまたはIPアドレスではないため、登録せず

def create(ipaddr, key)

if (addr = varid_ip?(ipaddr))

@hosts[addr] = {}

@hosts[addr]["keycode"] = key

@hosts[addr]["created_date"] = @hosts[addr]["updated_date"] = Time.now.getlocal

@hosts[addr]["status"] = "alive"

Reins.logger.info("#{addr} を追加しました")

key if store

else

false

end

# 登録されたステータスを変更する

# == パラメータ

# ipaddr:: 登録済みIPアドレス

# key:: 登録する IPアドレスをキーにした、接続用Keyをもつハッシュデータ

# status:: "alive" 稼働中, "dead" 異常発生し停止

# == 返り値

# "alive" or "dead":: 変更したホストのステータス

# false:: 未登録ホストの場合、または Keyがまちがっている

def get_status(ipaddr, key)

@hosts[ipaddr]["keycode"] == key ? @hosts[ipaddr]["status"] : false

rescue

false

end

# 登録されたステータス情報を得る

# == パラメータ

# ipaddr:: 登録済みIPアドレス

# key:: 登録する IPアドレスをキーにした、接続用Keyをもつハッシュデータ

# == 返り値

# "alive" or "dead":: 登録されているホストのステータス

# false:: 未登録、または停止中、または Keyがまちがっている

def set_status(ipaddr, key, status)

if @hosts[ipaddr]["keycode"] == key

@hosts[ipaddr]["status"] = status

@hosts[addr]["updated_date"] = Time.now.getlocal

store

status

else

false

end

rescue

false

end

# 登録済みホスト一覧を、IPアドレスをKey、接続KeyをValueとするハッシュで返す

# == 返り値

# hash: hash[ipアドレス] = key を一つの要素とする

def read_hostkeys

@hosts.each_key.map do |host|

[host, @hosts[host]["keycode"]]

end.to_h

end

# 登録済みホスト一覧を配列で返す

# == 返り値

# array: 登録済みのIPアドレス一覧

def read_hosts

@hosts.each_key.map { |host| host }

end

# 登録済みのアドレスを削除する

# == パラメータ

# addr: 削除対象のアドレス

# == 返り値

# string:: 削除された要素

# nil:: 削除すべき要素が見つからなかったとき

def delete(addr)

if @hosts.delete(addr)

Reins.logger.info("#{addr} を削除しました.")

store

addr

else

Reins.logger.warn("#{addr} を削除できません.")

nil

end

# まだアドレスが登録されていないかどうか

# == 返り値

# true:: アドレス未登録

# false:: 1つ以上のアドレスが登録済み

def empty?

@hosts.empty?

end

# coding: utf-8

# filename: lib/reins.rb

require "reins/version"
require "reins/dispatcher"
require "reins/auth_service"
require "reins/host_registry"
require "reins/task_control"
require "reins/config"

require "json"
require "socket"
require "ipaddr"

module Reins
  class << self
    # 指定されたポートでサーバを起動する
    # == パラメータ
    # port:: 割り当てるポート番号
    # == 返り値
    # Exception:: サーバが起動できなかった場合、例外を発生させ起動させない
    # TCPSocket:: 正常に起動した場合、Socket オブジェクトを返す
    def run_server(port)
      Reins.logger.info("Reins #{VERSION} を #{port} で起動します")
      TCPServer.new(port)
    rescue => e
      Reins.logger.error("Reins が起動できませんでした: #{e}")
      puts(e.to_s)
      exit
    end

    # 起動されているサーバを停止する
    # == パラメータ
    # server:: 起動中のサーバの Socket
    # == 返り値
    # 特になし
    def exit_server(server)
      Reins.logger.info("Reins #{VERSION} を終了します")
      Reins.regist_host.store
      server.close
      exit
    end

    #
    def connect_client(server)
      Thread.start(server.accept) do |c|
        client = Reins::Clients.new(c)
        status = {}
        status["keycode"] = client.keycode
        status["result"]  = client.command == 'auth' ? client.run_auth : client.run_command
        c.puts JSON.pretty_generate(status)
        c.close
      end
    rescue Interrupt
      exit_server(server)
    end
  end

  class Clients
    attr_accessor :addr, :keycode, :command, :options

    def initialize(client)
      @message = JSON.parse(client.gets)
      Reins.logger.debug(@message)
      @addr    = IPAddr.new(client.peeraddr[3]).native.to_s
      @keycode = @message["keycode"]
      @command = @message["command"]
      @options = @message["options"]
    end

    # 認証処理を行う
    # == パラメータ
    # 特になし
    # == 返り値
    # key:: 認証が成功した場合は接続用の認証キーを返す
    # false:: 認証が失敗した時は "false" 文字列を返す
    def run_auth
      Reins.logger.debug("#{addr} : 認証を行います")
      if (key = Reins.auth_service.authenticate_key(keycode, addr))
        key
      else
        "false"
      end
    end

    # サーバで実行されるコマンドを受け渡す
    # == パラメータ
    # 特になし
    # == 返り値
    # false:: 実行できなければ "false" 文字列を返す
    # false以外:: 実行された結果を、改行を含む文字列で返す
    def run_command
      Reins::Dispatch.new(addr, keycode).command(command, options)
    end
  end

  def start
    server = run_server(Reins.port)

    loop do
      connect_client(server)
    end
  end

  module_function :start
end

100

101

102

103

104

105

106

107

# coding: utf-8

# filename: lib/reins.rb

require "reins/version"

require "reins/dispatcher"

require "reins/auth_service"

require "reins/host_registry"

require "reins/task_control"

require "reins/config"

require "json"

require "socket"

require "ipaddr"

module Reins

class << self

# 指定されたポートでサーバを起動する

# == パラメータ

# port:: 割り当てるポート番号

# == 返り値

# Exception:: サーバが起動できなかった場合、例外を発生させ起動させない

# TCPSocket:: 正常に起動した場合、Socket オブジェクトを返す

def run_server(port)

Reins.logger.info("Reins #{VERSION} を #{port} で起動します")

TCPServer.new(port)

rescue => e

Reins.logger.error("Reins が起動できませんでした: #{e}")

puts(e.to_s)

exit

end

# 起動されているサーバを停止する

# == パラメータ

# server:: 起動中のサーバの Socket

# == 返り値

# 特になし

def exit_server(server)

Reins.logger.info("Reins #{VERSION} を終了します")

Reins.regist_host.store

server.close

exit

end

def connect_client(server)

Thread.start(server.accept) do |c|

client = Reins::Clients.new(c)

status = {}

status["keycode"] = client.keycode

status["result"] = client.command == 'auth' ? client.run_auth : client.run_command

c.puts JSON.pretty_generate(status)

c.close

end

rescue Interrupt

exit_server(server)

end

class Clients

attr_accessor :addr, :keycode, :command, :options

def initialize(client)

@message = JSON.parse(client.gets)

Reins.logger.debug(@message)

@addr = IPAddr.new(client.peeraddr[3]).native.to_s

@keycode = @message["keycode"]

@command = @message["command"]

@options = @message["options"]

end

# 認証処理を行う

# == パラメータ

# 特になし

# == 返り値

# key:: 認証が成功した場合は接続用の認証キーを返す

# false:: 認証が失敗した時は "false" 文字列を返す

def run_auth

Reins.logger.debug("#{addr} : 認証を行います")

if (key = Reins.auth_service.authenticate_key(keycode, addr))

key

else

"false"

end

# サーバで実行されるコマンドを受け渡す

# == パラメータ

# 特になし

# == 返り値

# false:: 実行できなければ "false" 文字列を返す

# false以外:: 実行された結果を、改行を含む文字列で返す

def run_command

Reins::Dispatch.new(addr, keycode).command(command, options)

end

def start

server = run_server(Reins.port)

loop do

connect_client(server)

end

module_function :start

end

# coding: utf-8

# filename: reins_agent.rb
require "reins_agent/config"
require "reins_agent/version"

require "json"
require "ipaddr"
require "socket"

module ReinsAgent
  class << self
    # サーバへ接続した後、指定したポート番号でサービスを開放する
    # == パラメータ
    # port:: エージェントが起動するためのポート番号
    # == 返り値
    # agent:: 起動されたサービスのソケット情報(@agent でも参照可)
    def run_agent(port)
      ReinsAgent.logger.info("Reins Agent #{VERSION} を #{port} で起動します")

      auth_command = JSON.generate("command" => "auth", "keycode" => ReinsAgent.client_key.to_s)
      throw unless (status = JSON.parse(ReinsAgent.exec(auth_command)))

      @cert_key = status["result"]
      ReinsAgent.logger.debug("認証キー : #{@cert_key} で認証が完了しました")

      @agent = TCPServer.new(ReinsAgent.client_port)
    rescue => e
      ReinsAgent.logger.fatal("Reins Agent が起動できませんでした: #{e}")
      exit
    end

    # サーバからのデータをパースする
    # == パラメータ
    # r:: リモートサーバのソケット情報
    # == 返り値
    # 特になし、ただし @message 連想配列へ、取得した情報を取得
    def define_value(r)
      @message = JSON.parse(r.gets)
      @message["IP address"] = IPAddr.new(r.peeraddr[3]).native.to_s
      ReinsAgent.logger.debug("addr = #{@message['IP address']}, keycode = #{@message['keycode']}, command = #{@message['command']}, options = #{@message['options']}")
    end

    # エージェントの終了処理
    # == パラメータ
    # 特になし
    # == 返り値
    # 常に終了
    def exit_agent
      ReinsAgent.logger.info("Reins Agent #{VERSION} を終了します")
      delete_command = JSON.generate("command" => "delete", "keycode" => @cert_key.to_s)
      ReinsAgent.exec(delete_command)
      @agent.close
      exit
    end

    # サーバへコマンドを送信し、その返り値を取得する
    # == パラメータ
    # command:: サーバへ送信するコマンド+オプションを指定
    # == 返り値
    # response:: サーバからの返り値(改行付き/複数行)
    def exec(command)
      ReinsAgent.logger.debug("コマンドを実行します : #{command}")
      s = TCPSocket.open(ReinsAgent.server_host, ReinsAgent.server_port)
      s.puts command
      response = s.read
      s.close if s
      response
    end

    # サーバからの接続用常駐エージェントを起動
    # == パラメータ
    # 特になし
    # == 返り値
    # 特になし
    def connect_agent
      Thread.start(@agent.accept) do |r|
        define_value(r)
        r.puts("OK")
        r.close
      end
    rescue Interrupt
      exit_agent
    end
  end

  #
  def start
    run_agent(ReinsAgent.client_port)
    list_command = JSON.generate("command" => "list", "keycode" => @cert_key.to_s)
    puts ReinsAgent.exec(list_command)

    loop do
      connect_agent
    end
  end

  module_function :start
end

# coding: utf-8

# filename: reins_agent.rb

require "reins_agent/config"

require "reins_agent/version"

require "json"

require "ipaddr"

require "socket"

module ReinsAgent

class << self

# サーバへ接続した後、指定したポート番号でサービスを開放する

# == パラメータ

# port:: エージェントが起動するためのポート番号

# == 返り値

# agent:: 起動されたサービスのソケット情報(@agent でも参照可)

def run_agent(port)

ReinsAgent.logger.info("Reins Agent #{VERSION} を #{port} で起動します")

auth_command = JSON.generate("command" => "auth", "keycode" => ReinsAgent.client_key.to_s)

throw unless (status = JSON.parse(ReinsAgent.exec(auth_command)))

@cert_key = status["result"]

ReinsAgent.logger.debug("認証キー : #{@cert_key} で認証が完了しました")

@agent = TCPServer.new(ReinsAgent.client_port)

rescue => e

ReinsAgent.logger.fatal("Reins Agent が起動できませんでした: #{e}")

exit

end

# サーバからのデータをパースする

# == パラメータ

# r:: リモートサーバのソケット情報

# == 返り値

# 特になし、ただし @message 連想配列へ、取得した情報を取得

def define_value(r)

@message = JSON.parse(r.gets)

@message["IP address"] = IPAddr.new(r.peeraddr[3]).native.to_s

ReinsAgent.logger.debug("addr = #{@message['IP address']}, keycode = #{@message['keycode']}, command = #{@message['command']}, options = #{@message['options']}")

end

# エージェントの終了処理

# == パラメータ

# 特になし

# == 返り値

# 常に終了

def exit_agent

ReinsAgent.logger.info("Reins Agent #{VERSION} を終了します")

delete_command = JSON.generate("command" => "delete", "keycode" => @cert_key.to_s)

ReinsAgent.exec(delete_command)

@agent.close

exit

end

# サーバへコマンドを送信し、その返り値を取得する

# == パラメータ

# command:: サーバへ送信するコマンド+オプションを指定

# == 返り値

# response:: サーバからの返り値(改行付き/複数行)

def exec(command)

ReinsAgent.logger.debug("コマンドを実行します : #{command}")

s = TCPSocket.open(ReinsAgent.server_host, ReinsAgent.server_port)

s.puts command

response = s.read

s.close if s

response

end

# サーバからの接続用常駐エージェントを起動

# == パラメータ

# 特になし

# == 返り値

# 特になし

def connect_agent

Thread.start(@agent.accept) do |r|

define_value(r)

r.puts("OK")

r.close

end

rescue Interrupt

exit_agent

end

def start

run_agent(ReinsAgent.client_port)

list_command = JSON.generate("command" => "list", "keycode" => @cert_key.to_s)

puts ReinsAgent.exec(list_command)

loop do

connect_agent

end

module_function :start

end

特集2　ラズパイ入門ボードの使い方（Vol.52掲載）

投稿日：2018.01.10　｜　カテゴリー：　コード

著者：米田聡

シェルスクリプトマガジンでは、小型コンピュータボード「Raspberry Pi」（ラズパイ）のプログラミングが楽しめる拡張ボード「ラズパイ入門ボード」を制作しました。本特集では、このラズパイ入門ボードに関する基本的な使い方の一部を紹介します。
記事本文掲載のシェルスクリプトマガジン vol.52は以下のリンク先でご購入できます。

LED1 = 14
LED2 = 15
LED3 = 12
LED4 = 16

SW1 = 4
SW2 = 17
SW3 = 5
SW4 = 6

LED1 = 14

LED2 = 15

LED3 = 12

LED4 = 16

SW1 = 4

SW2 = 17

SW3 = 5

SW4 = 6

# -*- coding: utf-8 -*-
# etnryboard.pyを読み込む
from entryboard import *
import time
import RPi.GPIO as GPIO

# 動作モード設定
GPIO.setmode(GPIO.BCM)
# GPIOモード設定
GPIO.setup(LED1, GPIO.OUT, initial=GPIO.LOW)
# LED1に1を出力
GPIO.output(LED1, GPIO.HIGH)
# 2秒待つ
time.sleep(2)
# LED1に0を出力
GPIO.output(LED1, GPIO.LOW)
# 終了処理
GPIO.cleanup(LED1)

# -*- coding: utf-8 -*-

# etnryboard.pyを読み込む

from entryboard import *

import time

import RPi.GPIO as GPIO

# 動作モード設定

GPIO.setmode(GPIO.BCM)

# GPIOモード設定

GPIO.setup(LED1, GPIO.OUT, initial=GPIO.LOW)

# LED1に1を出力

GPIO.output(LED1, GPIO.HIGH)

# 2秒待つ

time.sleep(2)

# LED1に0を出力

GPIO.output(LED1, GPIO.LOW)

# 終了処理

GPIO.cleanup(LED1)

# -*- coding: utf-8 -*-
from entryboard import *
import time
import RPi.GPIO as GPIO

# LEDが接続されているGPIOのリスト
leds = [LED1, LED2, LED3 ,LED4]

GPIO.setmode(GPIO.BCM)
GPIO.setup(leds, GPIO.OUT, initial=GPIO.LOW)

for i in range(3):
  for l in leds:
    GPIO.output(l, 1)
    time.sleep(1)
    GPIO.output(l, 0)
GPIO.cleanup(leds)

# -*- coding: utf-8 -*-

from entryboard import *

import time

import RPi.GPIO as GPIO

# LEDが接続されているGPIOのリスト

leds = [LED1, LED2, LED3 ,LED4]

GPIO.setmode(GPIO.BCM)

GPIO.setup(leds, GPIO.OUT, initial=GPIO.LOW)

for i in range(3):

for l in leds:

GPIO.output(l, 1)

time.sleep(1)

GPIO.output(l, 0)

GPIO.cleanup(leds)

# -*- coding: utf-8 -*-
from entryboard import *
import time
import sys
import RPi.GPIO as GPIO

switches = [SW1, SW2, SW3, SW4]
leds = [LED1, LED2, LED3, LED4]
GPIO.setmode(GPIO.BCM)
# スイッチのGPIOを入力に設定
GPIO.setup(switches, GPIO.IN)
GPIO.setup(leds, GPIO.OUT, initial=GPIO.LOW)

try:
  while True:
    for i in range(4):
      if GPIO.input(switches[i]) == GPIO.LOW:
        GPIO.output(leds[i], GPIO.HIGH)
      else:
        GPIO.output(leds[i], GPIO.LOW)

except KeyboardInterrupt:
  GPIO.cleanup(switches)
  GPIO.cleanup(leds)
  sys.exit()

# -*- coding: utf-8 -*-

from entryboard import *

import time

import sys

import RPi.GPIO as GPIO

switches = [SW1, SW2, SW3, SW4]

leds = [LED1, LED2, LED3, LED4]

GPIO.setmode(GPIO.BCM)

# スイッチのGPIOを入力に設定

GPIO.setup(switches, GPIO.IN)

GPIO.setup(leds, GPIO.OUT, initial=GPIO.LOW)

try:

while True:

for i in range(4):

if GPIO.input(switches[i]) == GPIO.LOW:

GPIO.output(leds[i], GPIO.HIGH)

else:

GPIO.output(leds[i], GPIO.LOW)

except KeyboardInterrupt:

GPIO.cleanup(switches)

GPIO.cleanup(leds)

sys.exit()

# -*- coding: utf-8 -*-
from entryboard import *
import time
import sys
import RPi.GPIO as GPIO

switches = [SW1, SW2, SW3, SW4]
leds = [LED1, LED2, LED3, LED4]

# スイッチのGPIOが変化したらこの関数が呼ばれる
def switch_event(channel):
  global leds
  global switches

  for i in range(4):
    if channel == switches[i]:
      if GPIO.input(channel) == GPIO.LOW:
        GPIO.output(leds[i], GPIO.HIGH)
      else:
        GPIO.output(leds[i], GPIO.LOW)

# プログラムはここから
if __name__ == "__main__":

  GPIO.setmode(GPIO.BCM)
  GPIO.setup(switches, GPIO.IN)
  GPIO.setup(leds, GPIO.OUT, initial=GPIO.LOW)

  for i in range(4):
    # イベントを登録する
    GPIO.add_event_detect(switches[i], GPIO.BOTH, bouncetime=60)
    GPIO.add_event_callback(switches[i], switch_event)

  try:
    # 1時間何もしない
    time.sleep(3600)

  except KeyboardInterrupt:
    GPIO.cleanup(switches)
    GPIO.cleanup(leds)
    sys.exit()

# -*- coding: utf-8 -*-

from entryboard import *

import time

import sys

import RPi.GPIO as GPIO

switches = [SW1, SW2, SW3, SW4]

leds = [LED1, LED2, LED3, LED4]

# スイッチのGPIOが変化したらこの関数が呼ばれる

def switch_event(channel):

global leds

global switches

for i in range(4):

if channel == switches[i]:

if GPIO.input(channel) == GPIO.LOW:

GPIO.output(leds[i], GPIO.HIGH)

else:

GPIO.output(leds[i], GPIO.LOW)

# プログラムはここから

if __name__ == "__main__":

GPIO.setmode(GPIO.BCM)

GPIO.setup(switches, GPIO.IN)

GPIO.setup(leds, GPIO.OUT, initial=GPIO.LOW)

for i in range(4):

# イベントを登録する

GPIO.add_event_detect(switches[i], GPIO.BOTH, bouncetime=60)

GPIO.add_event_callback(switches[i], switch_event)

try:

# 1時間何もしない

time.sleep(3600)

except KeyboardInterrupt:

GPIO.cleanup(switches)

GPIO.cleanup(leds)

sys.exit()

# -*- coding: utf-8 -*-
from entryboard import *
import time
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)
GPIO.setup(BUZZER, GPIO.OUT)
bz = GPIO.PWM(BUZZER, 1000)

bz.start(50)
time.sleep(2)
bz.stop()
GPIO.cleanup(BUZZER)

# -*- coding: utf-8 -*-

from entryboard import *

import time

import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)

GPIO.setup(BUZZER, GPIO.OUT)

bz = GPIO.PWM(BUZZER, 1000)

bz.start(50)

time.sleep(2)

bz.stop()

GPIO.cleanup(BUZZER)

# -*- coding: utf-8 -*-
from entryboard import *
import time
import pigpio

gpio = pigpio.pi()
gpio.set_mode(BUZZER, pigpio.OUTPUT)
gpio.hardware_PWM(BUZZER, 1000, 500000) # 1kHz, 50%
time.sleep(2)
gpio.hardware_PWM(BUZZER,0 ,0)
gpio.stop()

# -*- coding: utf-8 -*-

from entryboard import *

import time

import pigpio

gpio = pigpio.pi()

gpio.set_mode(BUZZER, pigpio.OUTPUT)

gpio.hardware_PWM(BUZZER, 1000, 500000) # 1kHz, 50%

time.sleep(2)

gpio.hardware_PWM(BUZZER,0 ,0)

gpio.stop()

# -*- coding: utf-8 -*-
from entryboard import *
import time
import pigpio

# 1オクターブの音階周波数リスト
scale = [ 523.251, 587.33, 659.255, 698.456, 783.991, 880, 987.767, 1046.502 ]
switches = [SW1, SW2, SW3, SW4]

bouncetime = 5 *1000 # 5ms
prev_tick = 0

# コールバック
def switch_event(channel, edge, tick):
  global bouncetime
  global prev_tick
  global scale
  global switches

  if (tick-prev_tick) < bouncetime:
     return
  prev_tick = tick

  for i in range(4):
    if switches[i] == channel:
      if edge == pigpio.LOW:
        gpio.hardware_PWM(BUZZER, scale[i], 500000)
      else:
        gpio.hardware_PWM(BUZZER, 0, 0)

if __name__ == "__main__":
  gpio = pigpio.pi()
  gpio.set_mode(BUZZER, pigpio.OUTPUT)
  for i in range(4):35
    # モードとコールバック
    gpio.set_mode(switches[i], pigpio.INPUT)
    gpio.callback(switches[i], pigpio.EITHER_EDGE, switch_event)
  try:
    time.sleep(3600)
  except KeyboardInterrupt:
    gpio.hardware_PWM(BUZZER, 0, 0)
    gpio.stop()

# -*- coding: utf-8 -*-

from entryboard import *

import time

import pigpio

# 1オクターブの音階周波数リスト

scale = [ 523.251, 587.33, 659.255, 698.456, 783.991, 880, 987.767, 1046.502 ]

switches = [SW1, SW2, SW3, SW4]

bouncetime = 5 *1000 # 5ms

prev_tick = 0

# コールバック

def switch_event(channel, edge, tick):

global bouncetime

global prev_tick

global scale

global switches

if (tick-prev_tick) < bouncetime:

return

prev_tick = tick

for i in range(4):

if switches[i] == channel:

if edge == pigpio.LOW:

gpio.hardware_PWM(BUZZER, scale[i], 500000)

else:

gpio.hardware_PWM(BUZZER, 0, 0)

if __name__ == "__main__":

gpio = pigpio.pi()

gpio.set_mode(BUZZER, pigpio.OUTPUT)

for i in range(4):35

# モードとコールバック

gpio.set_mode(switches[i], pigpio.INPUT)

gpio.callback(switches[i], pigpio.EITHER_EDGE, switch_event)

try:

time.sleep(3600)

except KeyboardInterrupt:

gpio.hardware_PWM(BUZZER, 0, 0)

gpio.stop()

LED5_R = 20
LED5_G = 22
LED5_B = 27

LED6_R = 26
LED6_G = 19
LED6_B = 13

LED5_R = 20

LED5_G = 22

LED5_B = 27

LED6_R = 26

LED6_G = 19

LED6_B = 13

# -*- coding: utf-8 -*-
from entryboard import *
import time
import RPi.GPIO as GPIO

led6 = [LED6_R, LED6_G, LED6_B]
duty = [50.0, 50.0, 50.0]
switches = [SW1, SW2, SW3, SW4]
pwm = []

GPIO.setmode(GPIO.BCM)
GPIO.setup(led6, GPIO.OUT)
GPIO.setup(switches, GPIO.IN)

for i in range(3):
  # 100Hzに設定
  pwm.append(GPIO.PWM(led6[i], 100))
  pwm[i].start(duty[i])
try:
  while True:
    for i in range(3):
      if GPIO.input(switches[i]) == GPIO.LOW:
        if GPIO.input(SW4) == GPIO.LOW:
          duty[i] = duty[i] - 5.0
          if duty[i] < 0.0:
            duty[i] = 0.0
          else:
            duty[i] = duty[i] + 5.0
            if duty[i] > 100.0:
              duty[i] = 100.0
      pwm[i].ChangeDutyCycle(duty[i])
      time.sleep(0.1)
except KeyboardInterrupt:
  GPIO.cleanup()

# -*- coding: utf-8 -*-

from entryboard import *

import time

import RPi.GPIO as GPIO

led6 = [LED6_R, LED6_G, LED6_B]

duty = [50.0, 50.0, 50.0]

switches = [SW1, SW2, SW3, SW4]

pwm = []

GPIO.setmode(GPIO.BCM)

GPIO.setup(led6, GPIO.OUT)

GPIO.setup(switches, GPIO.IN)

for i in range(3):

# 100Hzに設定

pwm.append(GPIO.PWM(led6[i], 100))

pwm[i].start(duty[i])

try:

while True:

for i in range(3):

if GPIO.input(switches[i]) == GPIO.LOW:

if GPIO.input(SW4) == GPIO.LOW:

duty[i] = duty[i] - 5.0

if duty[i] < 0.0:

duty[i] = 0.0

else:

duty[i] = duty[i] + 5.0

if duty[i] > 100.0:

duty[i] = 100.0

pwm[i].ChangeDutyCycle(duty[i])

time.sleep(0.1)

except KeyboardInterrupt:

GPIO.cleanup()

漢のUNIX　サードパーティ製ライブラリを使う（Vol.52掲載）

投稿日：2018.01.10　｜　カテゴリー：　コード

著者：後藤大地

これまでシステムに用意されている標準ライブラリだけを使ってソースコードを作成する例を取り上げてきたが、次のステップとしてサードパーティ製のライブラリを使う方法を紹介しよう。システムに標準で用意されているライブラリはすべての処理に対応しているわけではないので、特定の処理をしようと思ったらそれ向けに開発されたサードパーティ製ライブラリを利用することになる。
記事本文掲載のシェルスクリプトマガジンvol.52は以下のリンク先でご購入できます。

/* This is simple demonstration of how to use expat. This program
   reads an XML document from standard input and writes a line with
   the name of each element to standard output indenting child
   elements by one tab stop more than their parent element.
   It must be used with Expat compiled for UTF-8 output.
                            __  __            _
                         ___\ \/ /_ __   __ _| |_
                        / _ \\  /| '_ \ / _` | __|
                       |  __//  \| |_) | (_| | |_
                        \___/_/\_\ .__/ \__,_|\__|
                                 |_| XML parser

   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
   Copyright (c) 2000-2017 Expat development team
   Licensed under the MIT license:

   Permission is  hereby granted,  free of charge,  to any  person obtaining
   a  copy  of  this  software   and  associated  documentation  files  (the
   "Software"),  to  deal in  the  Software  without restriction,  including
   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
   distribute, sublicense, and/or sell copies of the Software, and to permit
   persons  to whom  the Software  is  furnished to  do so,  subject to  the
   following conditions:

   The above copyright  notice and this permission notice  shall be included
   in all copies or substantial portions of the Software.

   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
   USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include <stdio.h>
#include <expat.h>

#ifdef XML_LARGE_SIZE
# if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
#  define XML_FMT_INT_MOD "I64"
# else
#  define XML_FMT_INT_MOD "ll"
# endif
#else
# define XML_FMT_INT_MOD "l"
#endif

#ifdef XML_UNICODE_WCHAR_T
# include <wchar.h>
# define XML_FMT_STR "ls"
#else
# define XML_FMT_STR "s"
#endif

static void XMLCALL
startElement(void *userData, const XML_Char *name, const XML_Char **atts)
{
  int i;
  int *depthPtr = (int *)userData;
  (void)atts;

  for (i = 0; i < *depthPtr; i++)
    putchar('\t');
  printf("%" XML_FMT_STR "\n", name);
  *depthPtr += 1;
}

static void XMLCALL
endElement(void *userData, const XML_Char *name)
{
  int *depthPtr = (int *)userData;
  (void)name;

  *depthPtr -= 1;
}

int
main(int argc, char *argv[])
{
  char buf[BUFSIZ];
  XML_Parser parser = XML_ParserCreate(NULL);
  int done;
  int depth = 0;
  (void)argc;
  (void)argv;

  XML_SetUserData(parser, &depth);
  XML_SetElementHandler(parser, startElement, endElement);
  do {
    size_t len = fread(buf, 1, sizeof(buf), stdin);
    done = len < sizeof(buf);
    if (XML_Parse(parser, buf, (int)len, done) == XML_STATUS_ERROR) {
      fprintf(stderr,
              "%" XML_FMT_STR " at line %" XML_FMT_INT_MOD "u\n",
              XML_ErrorString(XML_GetErrorCode(parser)),
              XML_GetCurrentLineNumber(parser));
      return 1;
    }
  } while (!done);
  XML_ParserFree(parser);
  return 0;
}

100

101

102

103

104

/* This is simple demonstration of how to use expat. This program

reads an XML document from standard input and writes a line with

the name of each element to standard output indenting child

elements by one tab stop more than their parent element.

It must be used with Expat compiled for UTF-8 output.

__ __ _

___\ \/ /_ __ __ _| |_

/ _ \\ /| '_ \ / _` | __|

| __// \| |_) | (_| | |_

\___/_/\_\ .__/ \__,_|\__|

|_| XML parser

Licensed under the MIT license:

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the

"Software"), to deal in the Software without restriction, including

without limitation the rights to use, copy, modify, merge, publish,

distribute, sublicense, and/or sell copies of the Software, and to permit

persons to whom the Software is furnished to do so, subject to the

following conditions:

The above copyright notice and this permission notice shall be included

in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

USE OR OTHER DEALINGS IN THE SOFTWARE.

#include <stdio.h>

#include <expat.h>

#ifdef XML_LARGE_SIZE

# if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400

# define XML_FMT_INT_MOD "I64"

# else

# define XML_FMT_INT_MOD "ll"

# endif

#else

# define XML_FMT_INT_MOD "l"

#endif

#ifdef XML_UNICODE_WCHAR_T

# include <wchar.h>

# define XML_FMT_STR "ls"

#else

# define XML_FMT_STR "s"

#endif

static void XMLCALL

startElement(void *userData, const XML_Char *name, const XML_Char **atts)

{

int i;

int *depthPtr = (int *)userData;

(void)atts;

for (i = 0; i < *depthPtr; i++)

putchar('\t');

printf("%" XML_FMT_STR "\n", name);

*depthPtr += 1;

}

static void XMLCALL

endElement(void *userData, const XML_Char *name)

{

int *depthPtr = (int *)userData;

(void)name;

*depthPtr -= 1;

}

int

main(int argc, char *argv[])

{

char buf[BUFSIZ];

XML_Parser parser = XML_ParserCreate(NULL);

int done;

int depth = 0;

(void)argc;

(void)argv;

XML_SetUserData(parser, &depth);

XML_SetElementHandler(parser, startElement, endElement);

do {

size_t len = fread(buf, 1, sizeof(buf), stdin);

done = len < sizeof(buf);

if (XML_Parse(parser, buf, (int)len, done) == XML_STATUS_ERROR) {

fprintf(stderr,

"%" XML_FMT_STR " at line %" XML_FMT_INT_MOD "u\n",

XML_ErrorString(XML_GetErrorCode(parser)),

XML_GetCurrentLineNumber(parser));

return 1;

}

} while (!done);

XML_ParserFree(parser);

return 0;

}

#include <stdio.h>
#include <expat.h>

static void XMLCALL
startElement(void *userData, const XML_Char * name, 
		const XML_Char ** atts)
{
	int i;
	int *depthPtr = (int *)userData;
	(void)atts;

	for (i = 0; i < *depthPtr; i++)
		putchar('\t');
	printf("%s\n", name);
	*depthPtr += 1;
}

static void XMLCALL
endElement(void *userData, const XML_Char * name)
{
	int *depthPtr = (int *)userData;
	(void)name;

	*depthPtr -= 1;
}

int
main(int argc, char *argv[])
{
	char buf[BUFSIZ];
	XML_Parser parser = XML_ParserCreate(NULL);
	int done;
	int depth = 0;
	(void)argc;
	(void)argv;

	XML_SetUserData(parser, &depth);
	XML_SetElementHandler(parser, startElement, endElement);
	do {
		size_t len = fread(buf, 1, sizeof(buf), stdin);
		done = len < sizeof(buf);
		if (XML_Parse(parser, buf, (int)len, done) == 
			XML_STATUS_ERROR) {
			fprintf(stderr,
				"%s at line %lu\n",
				XML_ErrorString(XML_GetErrorCode(parser)),
				XML_GetCurrentLineNumber(parser));
			return 1;
		}
	} while (!done);
	XML_ParserFree(parser);
	return 0;
}

#include <stdio.h>

#include <expat.h>

static void XMLCALL

startElement(void *userData, const XML_Char * name,

const XML_Char ** atts)

{

int i;

int *depthPtr = (int *)userData;

(void)atts;

for (i = 0; i < *depthPtr; i++)

putchar('\t');

printf("%s\n", name);

*depthPtr += 1;

}

static void XMLCALL

endElement(void *userData, const XML_Char * name)

{

int *depthPtr = (int *)userData;

(void)name;

*depthPtr -= 1;

}

int

main(int argc, char *argv[])

{

char buf[BUFSIZ];

XML_Parser parser = XML_ParserCreate(NULL);

int done;

int depth = 0;

(void)argc;

(void)argv;

XML_SetUserData(parser, &depth);

XML_SetElementHandler(parser, startElement, endElement);

do {

size_t len = fread(buf, 1, sizeof(buf), stdin);

done = len < sizeof(buf);

if (XML_Parse(parser, buf, (int)len, done) ==

XML_STATUS_ERROR) {

fprintf(stderr,

"%s at line %lu\n",

XML_ErrorString(XML_GetErrorCode(parser)),

XML_GetCurrentLineNumber(parser));

return 1;

}

} while (!done);

XML_ParserFree(parser);

return 0;

}

<?xml version="1.0" encoding="UTF-8"?>

<document>
 <docgroup>
  <docinfo>
   <title><p>タイトル</p></title>
   <author><p>名前</p></author>
   <firstedition><p>編集開始日</p></firstedition>
   <lastmodified><p>編集終了日</p></lastmodified>
  </docinfo>

  <docgroup>
   <docinfo>
    <title><p>章タイトル</p></title>
   </docinfo>

   <p>説明1</p>

   <p>説明2</p>
  </docgroup>
 </docgroup>
</document>

<?xml version="1.0" encoding="UTF-8"?>

<firstedition>編集開始日</firstedition>

<lastmodified>編集終了日</lastmodified>

</docinfo>

<title>章タイトル</title>

</docinfo>

説明1

説明2

</docgroup>

</document>

// XMLパーサを作成
XML_Parser parser = XML_ParserCreate(NULL);

// 開始タグと終了タグを読み込んだタイミングで実行される
// 関数を登録
XML_SetElementHandler(parser, startElement, endElement);

// パースを実行（データをバッファに読み込みながら、デー
// タが終了するまでこの処理を繰り返す）
XML_Parse(parser, buf, (int)len, done);

// 使用したXMLパーサを解放
XML_ParserFree(parser);

// XMLパーサを作成

XML_Parser parser = XML_ParserCreate(NULL);

// 開始タグと終了タグを読み込んだタイミングで実行される

// 関数を登録

XML_SetElementHandler(parser, startElement, endElement);

// パースを実行（データをバッファに読み込みながら、デー

// タが終了するまでこの処理を繰り返す）

XML_Parse(parser, buf, (int)len, done);

// 使用したXMLパーサを解放

XML_ParserFree(parser);

#include <stdio.h>
#include <expat.h>

static void XMLCALL begin(void *, const XML_Char*, const XML_Char**);
static void XMLCALL end(void *, const XML_Char *);

static int depth = 0;

int
main(int argc, char *argv[])
{
	char buf[BUFSIZ];
	int len, done;
	XML_Parser parser = XML_ParserCreate(NULL);

	XML_SetElementHandler(parser, begin, end);
	do {
		len = fread(buf, 1, sizeof(buf), stdin);
		done = len < sizeof(buf);
		if (XML_Parse(parser, buf, (int)len, done) == 
			XML_STATUS_ERROR)
			return 1;
	} while (!done);

	XML_ParserFree(parser);
	return 0;
}

static void XMLCALL
begin(void *d, const XML_Char *name, const XML_Char **attr)
{
	for (int i = 0; i < depth; i++)
		printf("→");

	printf("%s\n", name);
	++depth;
}

static void XMLCALL
end(void *d, const XML_Char * name)
{
	--depth;
}

#include <stdio.h>

#include <expat.h>

static void XMLCALL begin(void *, const XML_Char*, const XML_Char**);

static void XMLCALL end(void *, const XML_Char *);

static int depth = 0;

int

main(int argc, char *argv[])

{

char buf[BUFSIZ];

int len, done;

XML_Parser parser = XML_ParserCreate(NULL);

XML_SetElementHandler(parser, begin, end);

do {

len = fread(buf, 1, sizeof(buf), stdin);

done = len < sizeof(buf);

if (XML_Parse(parser, buf, (int)len, done) ==

XML_STATUS_ERROR)

return 1;

} while (!done);

XML_ParserFree(parser);

return 0;

}

static void XMLCALL

begin(void *d, const XML_Char *name, const XML_Char **attr)

{

for (int i = 0; i < depth; i++)

printf("→");

printf("%s\n", name);

++depth;

}

static void XMLCALL

end(void *d, const XML_Char * name)

{

--depth;

}

Open USP Tukubaiシンプルレシピ　Part1 テキスト編　（後半・ルービックキューブをつくる　など）

投稿日：2018.01.9　｜　カテゴリー：　記事

Tukubai、それはシェルスクリプトの使い易さを加速させるコマンド群。
前号では、そのオープン版“Open usp Tukubai”を紹介したが、やり残したことがあった。
豊富なレシピの紹介である。
そこで今号と次号の二回に渡り、Tukubaiの、特に実際のコーディングスタイルが分かり易いレシピを特集する。
「シェルスクリプトとは、僅かなコマンドの追加で、こんなにも応用の効く言語になるのか!」と、あなたはきっと驚くことだろう。

written by USPマガジン編集部

本記事は、USP MAGAZINE vol.5(2012年夏号)掲載記事のWEB再録記事(後半部分)です。

前半はこちら→シェルスクリプトに何でもおまかせ　Open USP Tukubaiシンプルレシピ　Part1 テキスト編　（前半）

本記事掲載のUSP MAGAZINE vol.5は以下リンク先でご購入できます。

レシピ２　ルービックキューブを作る。

問題

Tukubai はシェルスクリプトをデータベース言語化させるためだけのコマンドセットではないというが、それならもっと一般的な例は無いのか。

数理的な操作の様子が伺えるコードが見てみたい。例えば、何らかの科学技術計算を行っているプログラムであれば、それがわかりやすいと思うのだが。

解答

実際に科学技術計算にも利用しているのだが、そのような例は専門分野の知識から解説しなければならない。

そこでここでは専門分野知識の解説が不要なゲームのレシピを紹介しよう。数学パズル的要素が強いゲームであれば、数理的な操作も見え易いからだ。

■ サンプルプログラム
そこでルービックキューブ（3 × 3 のオーソドックスなもの）を作ってみた。

ルービックキューブは、立方体の一面が一つの行列に対応した6 つの行列であると見なせる。キューブを動かすと、その行列のうちの一つで± 90°回転が発生し、それに伴って隣接する4 つの面に相当する行列の一部要素が、別の行列に移動する。この動きを、シミュレートしようというものである。

UECでの解説はこちら。

#!/bin/bash
#
# ３ｘ３ルービックキューブ
# Written by N.Tounaka(xxxxxxx@usp-lab.com)
# Date : 5 Jun.2012
# Arranged by USP MAGAZINE(xxx@usp-lab.com)
# Date : 6 Jun.2012
# Ｕ
# 立方体(６面体）の展開図＝ＬＦＲＢ
# Ｄ
# F:fore B:back U:up D:down R:right L:left
#
# 関数ｆ：面Ｆを時計回り（右９０度回転）
# 関数Ｆ：面Ｆを反時計回り（左９０度回転）

# 変数定義(一時ファイルパス/着色データ)
tmp=tmp
F=`printf '\033[43mF\033[00m'`
U=`printf '\033[46mU\033[00m'`
R=`printf '\033[41mR\033[00m'`
B=`printf '\033[45mB\033[00m'`
D=`printf '\033[44mD\033[00m'`
L=`printf '\033[42mL\033[00m'`

# 関数のインクルード
source rubik-cube.func

# 初期化/シャッフル/答え作り(シャッフルの逆操作を記録)
init
rand ${1-=10} 2> $tmp-ans
ans=$(tac $tmp-ans | yarr -d | tr a-zA-Z A-Za-z)

# ゲームの開始
n=1
while true; do

echo " Fore Up Right Back Down Left"
echo " ---------------------------------------------"
ycat -3 F U R B D L |
ycat /dev/null - |
sed -e "s/F/$F/g; s/U/$U/g; s/R/$R/g" \
-e "s/B/$B/g; s/D/$D/g; s/L/$L/g"
echo "<-f F-> <-u U-> <-r R-> <-b B-> <-d D-> <-l L->"
echo -n "${ans}[$n]> "
read -n 1 scr
echo
[ "$scr" = "q" ] && break
eval ${scr} 2> /dev/null
n=$((n+1))

done

rm F B U D R L $tmp-*
exit 0

#!/bin/bash

# ３ｘ３ルービックキューブ

# Written by N.Tounaka(xxxxxxx@usp-lab.com)

# Date : 5 Jun.2012

# Arranged by USP MAGAZINE(xxx@usp-lab.com)

# Date : 6 Jun.2012

# Ｕ

# 立方体(６面体）の展開図＝ＬＦＲＢ

# Ｄ

# F:fore B:back U:up D:down R:right L:left

# 関数ｆ：面Ｆを時計回り（右９０度回転）

# 関数Ｆ：面Ｆを反時計回り（左９０度回転）

# 変数定義(一時ファイルパス/着色データ)

tmp=tmp

F=`printf '\033[43mF\033[00m'`

U=`printf '\033[46mU\033[00m'`

R=`printf '\033[41mR\033[00m'`

B=`printf '\033[45mB\033[00m'`

D=`printf '\033[44mD\033[00m'`

L=`printf '\033[42mL\033[00m'`

# 関数のインクルード

source rubik-cube.func

# 初期化/シャッフル/答え作り(シャッフルの逆操作を記録)

init

rand ${1-=10} 2> $tmp-ans

ans=$(tac $tmp-ans | yarr -d | tr a-zA-Z A-Za-z)

# ゲームの開始

n=1

while true; do

echo " Fore Up Right Back Down Left"

echo " ---------------------------------------------"

ycat -3 F U R B D L |

ycat /dev/null - |

sed -e "s/F/$F/g; s/U/$U/g; s/R/$R/g" \

-e "s/B/$B/g; s/D/$D/g; s/L/$L/g"

echo "<-f F-> <-u U-> <-r R-> <-b B-> <-d D-> <-l L->"

echo -n "${ans}[$n]> "

read -n 1 scr

echo

[ "$scr" = "q" ] && break

eval ${scr} 2> /dev/null

n=$((n+1))

done

rm F B U D R L $tmp-*

exit 0

リスト３．rubik-cube.func : ルービックキューブプログラム（ファイル2・関数定義）

# RUBIK-CUBE エンジン
#
# Written by N.Tounaka(xxxxxxx@usp-lab.com)
#                        Date : 5 Jun.2012
# Arranged by USP MAGAZINE(xxx@usp-lab.com)
#                        Date : 6 Jun.2012

init ()    # 色が揃ったキューブをセットする
{
  for surf in F U B D R L; do
    yes "$surf" |
    head -9     |
    yarr -3     > $surf
  done
}

r ()  # Ｒ面(Right)の９０度時計回り
{
  self 3 F | cat           > $tmp-f
  self 3 U | tac           > $tmp-u
  self 1 B | cat           > $tmp-b
  self 1 D | tac           > $tmp-d
  delf 3 F | ycat - $tmp-d > $tmp-w; mv $tmp-w F 
  delf 3 U | ycat - $tmp-f > $tmp-w; mv $tmp-w U
  delf 1 B | ycat $tmp-u - > $tmp-w; mv $tmp-w B 
  delf 1 D | ycat $tmp-b - > $tmp-w; mv $tmp-w D 
  tateyoko R | self 3 2 1  > $tmp-w; mv $tmp-w R
}

R ()  # Ｒ面(Right)の９０度反時計回り
{
  self 3 F | tac           > $tmp-f
  self 3 U | cat           > $tmp-u
  self 1 B | tac           > $tmp-b
  self 1 D | cat           > $tmp-d
  delf 3 F | ycat - $tmp-u > $tmp-w; mv $tmp-w F 
  delf 3 U | ycat - $tmp-b > $tmp-w; mv $tmp-w U
  delf 1 B | ycat $tmp-d - > $tmp-w; mv $tmp-w B 
  delf 1 D | ycat $tmp-f - > $tmp-w; mv $tmp-w D 
  tateyoko R | tac         > $tmp-w; mv $tmp-w R
}

l ()  # Ｌ面(Left)の９０度時計回り
{
  self 1 F | tac           > $tmp-f
  self 1 U | cat           > $tmp-u
  self 3 B | tac           > $tmp-b
  self 3 D | cat           > $tmp-d
  delf 1 F | ycat $tmp-u - > $tmp-w; mv $tmp-w F 
  delf 1 U | ycat $tmp-b - > $tmp-w; mv $tmp-w U
  delf 3 B | ycat - $tmp-d > $tmp-w; mv $tmp-w B 
  delf 3 D | ycat - $tmp-f > $tmp-w; mv $tmp-w D 
  tateyoko L | self 3 2 1  > $tmp-w; mv $tmp-w L
}

L ()  # Ｌ面(Left)の９０度反時計回り
{
  self 1 F | cat           > $tmp-f
  self 1 U | tac           > $tmp-u
  self 3 B | cat           > $tmp-b
  self 3 D | tac           > $tmp-d
  delf 1 F | ycat $tmp-d - > $tmp-w; mv $tmp-w F 
  delf 1 U | ycat $tmp-f - > $tmp-w; mv $tmp-w U
  delf 3 B | ycat - $tmp-u > $tmp-w; mv $tmp-w B 
  delf 3 D | ycat - $tmp-b > $tmp-w; mv $tmp-w D 
  tateyoko L | tac         > $tmp-w; mv $tmp-w L
}

f ()  # Ｆ面(Front)の９０度時計回り
{
  tail -1 U | tarr              > $tmp-u
  self  1 R | yarr              > $tmp-r
  tail -1 D | tarr | tac        > $tmp-d
  self  3 L | yarr | self 3 2 1 > $tmp-l 
  ctail -1 U | cat - $tmp-l     > $tmp-w; mv $tmp-w U
  delf 1 R   | ycat $tmp-u -    > $tmp-w; mv $tmp-w R
  ctail -1 D | cat - $tmp-r     > $tmp-w; mv $tmp-w D
  delf 3 L   | ycat - $tmp-d    > $tmp-w; mv $tmp-w L
  tateyoko F | self 3 2 1       > $tmp-w; mv $tmp-w F
}

F ()  # Ｆ面(Front)の９０度反時計回り
{
  tail -1 U | tarr | tac        > $tmp-u
  self  1 R | yarr              > $tmp-r
  tail -1 D | tarr              > $tmp-d
  self  3 L | yarr | self 3 2 1 > $tmp-l
  ctail -1 U | cat - $tmp-r     > $tmp-w; mv $tmp-w U
  delf 1 R   | ycat $tmp-d -    > $tmp-w; mv $tmp-w R
  ctail -1 D | cat - $tmp-l     > $tmp-w; mv $tmp-w D
  delf 3 L   | ycat - $tmp-u    > $tmp-w; mv $tmp-w L
  tateyoko F | tac              > $tmp-w; mv $tmp-w F
}

b ()  # Ｂ面(Back)の９０度時計回り
{
  head -1 U | tarr | tac        > $tmp-u
  self 1 L  | yarr | self 3 2 1 > $tmp-l
  head -1 D | tarr              > $tmp-d
  self 3 R  | yarr              > $tmp-r
  tail -n +2 U | cat $tmp-r -   > $tmp-w; mv $tmp-w U
  delf 1 L     | ycat $tmp-u -  > $tmp-w; mv $tmp-w L
  tail -n +2 D | cat $tmp-l -   > $tmp-w; mv $tmp-w D
  delf 3 R     | ycat - $tmp-d  > $tmp-w; mv $tmp-w R
  tateyoko B | self 3 2 1       > $tmp-w; mv $tmp-w B
}

B ()  # Ｂ面(Back)の９０度反時計回り
{
  head -1 U | tarr              > $tmp-u
  self 1 L  | yarr | self 3 2 1 > $tmp-l
  head -1 D | tarr | tac        > $tmp-d
  self 3 R  | yarr              > $tmp-r
  tail -n +2 U | cat $tmp-l -   > $tmp-w; mv $tmp-w U
  delf 1 L     | ycat $tmp-d -  > $tmp-w; mv $tmp-w L
  tail -n +2 D | cat $tmp-r -   > $tmp-w; mv $tmp-w D
  delf 3 R     | ycat - $tmp-u  > $tmp-w; mv $tmp-w R
  tateyoko B | tac              > $tmp-w; mv $tmp-w B
}

u ()  # Ｕ面(under)の９０度時計回り
{
  head -1 R                   > $tmp-r
  head -1 F                   > $tmp-f
  head -1 L                   > $tmp-l
  head -1 B                   > $tmp-b
  tail -n +2 R | cat $tmp-b - > $tmp-w; mv $tmp-w R
  tail -n +2 F | cat $tmp-r - > $tmp-w; mv $tmp-w F
  tail -n +2 L | cat $tmp-f - > $tmp-w; mv $tmp-w L
  tail -n +2 B | cat $tmp-l - > $tmp-w; mv $tmp-w B
  tateyoko U | self 3 2 1     > $tmp-w; mv $tmp-w U
}

U ()  # Ｕ面(under)の９０度反時計回り
{
  head -1 R                   > $tmp-r
  head -1 F                   > $tmp-f
  head -1 L                   > $tmp-l
  head -1 B                   > $tmp-b
  tail -n +2 R | cat $tmp-f - > $tmp-w; mv $tmp-w R
  tail -n +2 F | cat $tmp-l - > $tmp-w; mv $tmp-w F
  tail -n +2 L | cat $tmp-b - > $tmp-w; mv $tmp-w L
  tail -n +2 B | cat $tmp-r - > $tmp-w; mv $tmp-w B
  tateyoko U | tac            > $tmp-w; mv $tmp-w U
}

d ()  # Ｄ面(down)の９０度時計回り
{
  tail -1 R                 > $tmp-r
  tail -1 F                 > $tmp-f
  tail -1 L                 > $tmp-l
  tail -1 B                 > $tmp-b
  ctail -1 R | cat - $tmp-f > $tmp-w; mv $tmp-w R
  ctail -1 F | cat - $tmp-l > $tmp-w; mv $tmp-w F
  ctail -1 L | cat - $tmp-b > $tmp-w; mv $tmp-w L
  ctail -1 B | cat - $tmp-r > $tmp-w; mv $tmp-w B
  tateyoko D | self 3 2 1 > $tmp-w; mv $tmp-w D
}

D ()  # Ｄ面(down)の９０度反時計回り
{
  tail -1 R                 > $tmp-r
  tail -1 F                 > $tmp-f
  tail -1 L                 > $tmp-l
  tail -1 B                 > $tmp-b
  ctail -1 R | cat - $tmp-b > $tmp-w; mv $tmp-w R
  ctail -1 F | cat - $tmp-r > $tmp-w; mv $tmp-w F
  ctail -1 L | cat - $tmp-f > $tmp-w; mv $tmp-w L
  ctail -1 B | cat - $tmp-l > $tmp-w; mv $tmp-w B
  tateyoko D | tac          > $tmp-w; mv $tmp-w D
} 

# ランダムに指定回数キューブを回転させる
rand ()
{
  func=(f F b B u U d D r R l L)
  for((i=0; i<$1; i++)); do proc=${func[$((${RANDOM}%12))]} echo $proc 1>&2   # 手続きを保存する
    eval $proc        # 関数の実行
  done
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

# RUBIK-CUBE エンジン

# Written by N.Tounaka(xxxxxxx@usp-lab.com)

# Date : 5 Jun.2012

# Arranged by USP MAGAZINE(xxx@usp-lab.com)

# Date : 6 Jun.2012

init () # 色が揃ったキューブをセットする

{

for surf in F U B D R L; do

yes "$surf" |

head -9 |

yarr -3 > $surf

done

}

r () # Ｒ面(Right)の９０度時計回り

{

self 3 F | cat > $tmp-f

self 3 U | tac > $tmp-u

self 1 B | cat > $tmp-b

self 1 D | tac > $tmp-d

delf 3 F | ycat - $tmp-d > $tmp-w; mv $tmp-w F

delf 3 U | ycat - $tmp-f > $tmp-w; mv $tmp-w U

delf 1 B | ycat $tmp-u - > $tmp-w; mv $tmp-w B

delf 1 D | ycat $tmp-b - > $tmp-w; mv $tmp-w D

tateyoko R | self 3 2 1 > $tmp-w; mv $tmp-w R

}

R () # Ｒ面(Right)の９０度反時計回り

{

self 3 F | tac > $tmp-f

self 3 U | cat > $tmp-u

self 1 B | tac > $tmp-b

self 1 D | cat > $tmp-d

delf 3 F | ycat - $tmp-u > $tmp-w; mv $tmp-w F

delf 3 U | ycat - $tmp-b > $tmp-w; mv $tmp-w U

delf 1 B | ycat $tmp-d - > $tmp-w; mv $tmp-w B

delf 1 D | ycat $tmp-f - > $tmp-w; mv $tmp-w D

tateyoko R | tac > $tmp-w; mv $tmp-w R

}

l () # Ｌ面(Left)の９０度時計回り

{

self 1 F | tac > $tmp-f

self 1 U | cat > $tmp-u

self 3 B | tac > $tmp-b

self 3 D | cat > $tmp-d

delf 1 F | ycat $tmp-u - > $tmp-w; mv $tmp-w F

delf 1 U | ycat $tmp-b - > $tmp-w; mv $tmp-w U

delf 3 B | ycat - $tmp-d > $tmp-w; mv $tmp-w B

delf 3 D | ycat - $tmp-f > $tmp-w; mv $tmp-w D

tateyoko L | self 3 2 1 > $tmp-w; mv $tmp-w L

}

L () # Ｌ面(Left)の９０度反時計回り

{

self 1 F | cat > $tmp-f

self 1 U | tac > $tmp-u

self 3 B | cat > $tmp-b

self 3 D | tac > $tmp-d

delf 1 F | ycat $tmp-d - > $tmp-w; mv $tmp-w F

delf 1 U | ycat $tmp-f - > $tmp-w; mv $tmp-w U

delf 3 B | ycat - $tmp-u > $tmp-w; mv $tmp-w B

delf 3 D | ycat - $tmp-b > $tmp-w; mv $tmp-w D

tateyoko L | tac > $tmp-w; mv $tmp-w L

}

f () # Ｆ面(Front)の９０度時計回り

{

tail -1 U | tarr > $tmp-u

self 1 R | yarr > $tmp-r

tail -1 D | tarr | tac > $tmp-d

self 3 L | yarr | self 3 2 1 > $tmp-l

ctail -1 U | cat - $tmp-l > $tmp-w; mv $tmp-w U

delf 1 R | ycat $tmp-u - > $tmp-w; mv $tmp-w R

ctail -1 D | cat - $tmp-r > $tmp-w; mv $tmp-w D

delf 3 L | ycat - $tmp-d > $tmp-w; mv $tmp-w L

tateyoko F | self 3 2 1 > $tmp-w; mv $tmp-w F

}

F () # Ｆ面(Front)の９０度反時計回り

{

tail -1 U | tarr | tac > $tmp-u

self 1 R | yarr > $tmp-r

tail -1 D | tarr > $tmp-d

self 3 L | yarr | self 3 2 1 > $tmp-l

ctail -1 U | cat - $tmp-r > $tmp-w; mv $tmp-w U

delf 1 R | ycat $tmp-d - > $tmp-w; mv $tmp-w R

ctail -1 D | cat - $tmp-l > $tmp-w; mv $tmp-w D

delf 3 L | ycat - $tmp-u > $tmp-w; mv $tmp-w L

tateyoko F | tac > $tmp-w; mv $tmp-w F

}

b () # Ｂ面(Back)の９０度時計回り

{

head -1 U | tarr | tac > $tmp-u

self 1 L | yarr | self 3 2 1 > $tmp-l

head -1 D | tarr > $tmp-d

self 3 R | yarr > $tmp-r

tail -n +2 U | cat $tmp-r - > $tmp-w; mv $tmp-w U

delf 1 L | ycat $tmp-u - > $tmp-w; mv $tmp-w L

tail -n +2 D | cat $tmp-l - > $tmp-w; mv $tmp-w D

delf 3 R | ycat - $tmp-d > $tmp-w; mv $tmp-w R

tateyoko B | self 3 2 1 > $tmp-w; mv $tmp-w B

}

B () # Ｂ面(Back)の９０度反時計回り

{

head -1 U | tarr > $tmp-u

self 1 L | yarr | self 3 2 1 > $tmp-l

head -1 D | tarr | tac > $tmp-d

self 3 R | yarr > $tmp-r

tail -n +2 U | cat $tmp-l - > $tmp-w; mv $tmp-w U

delf 1 L | ycat $tmp-d - > $tmp-w; mv $tmp-w L

tail -n +2 D | cat $tmp-r - > $tmp-w; mv $tmp-w D

delf 3 R | ycat - $tmp-u > $tmp-w; mv $tmp-w R

tateyoko B | tac > $tmp-w; mv $tmp-w B

}

u () # Ｕ面(under)の９０度時計回り

{

head -1 R > $tmp-r

head -1 F > $tmp-f

head -1 L > $tmp-l

head -1 B > $tmp-b

tail -n +2 R | cat $tmp-b - > $tmp-w; mv $tmp-w R

tail -n +2 F | cat $tmp-r - > $tmp-w; mv $tmp-w F

tail -n +2 L | cat $tmp-f - > $tmp-w; mv $tmp-w L

tail -n +2 B | cat $tmp-l - > $tmp-w; mv $tmp-w B

tateyoko U | self 3 2 1 > $tmp-w; mv $tmp-w U

}

U () # Ｕ面(under)の９０度反時計回り

{

head -1 R > $tmp-r

head -1 F > $tmp-f

head -1 L > $tmp-l

head -1 B > $tmp-b

tail -n +2 R | cat $tmp-f - > $tmp-w; mv $tmp-w R

tail -n +2 F | cat $tmp-l - > $tmp-w; mv $tmp-w F

tail -n +2 L | cat $tmp-b - > $tmp-w; mv $tmp-w L

tail -n +2 B | cat $tmp-r - > $tmp-w; mv $tmp-w B

tateyoko U | tac > $tmp-w; mv $tmp-w U

}

d () # Ｄ面(down)の９０度時計回り

{

tail -1 R > $tmp-r

tail -1 F > $tmp-f

tail -1 L > $tmp-l

tail -1 B > $tmp-b

ctail -1 R | cat - $tmp-f > $tmp-w; mv $tmp-w R

ctail -1 F | cat - $tmp-l > $tmp-w; mv $tmp-w F

ctail -1 L | cat - $tmp-b > $tmp-w; mv $tmp-w L

ctail -1 B | cat - $tmp-r > $tmp-w; mv $tmp-w B

tateyoko D | self 3 2 1 > $tmp-w; mv $tmp-w D

}

D () # Ｄ面(down)の９０度反時計回り

{

tail -1 R > $tmp-r

tail -1 F > $tmp-f

tail -1 L > $tmp-l

tail -1 B > $tmp-b

ctail -1 R | cat - $tmp-b > $tmp-w; mv $tmp-w R

ctail -1 F | cat - $tmp-r > $tmp-w; mv $tmp-w F

ctail -1 L | cat - $tmp-f > $tmp-w; mv $tmp-w L

ctail -1 B | cat - $tmp-l > $tmp-w; mv $tmp-w B

tateyoko D | tac > $tmp-w; mv $tmp-w D

}

# ランダムに指定回数キューブを回転させる

rand ()

{

func=(f F b B u U d D r R l L)

for((i=0; i<$1; i++)); do proc=${func[$((${RANDOM}%12))]} echo $proc 1>&2 # 手続きを保存する

eval $proc # 関数の実行

done

}

shell-mag ブログの 2018年1月のアーカイブを表示しています。

-->

ソースコードの入手先

レシピ２ ルービックキューブを作る。

問題

解答

レシピ２　ルービックキューブを作る。